Блог

     struct X
    {

    private:
        int value_;
    public:
        X():value_(int())
        {}
        X(int value):value_(value)
        {}
        friend
            //int operator (X lhs, X rhs);//THIS WILL WORK  
//BUT THE ONE BELOW WON'T
        auto operator (const Xamp; lhs, const Xamp; rhs)->decltype(lhs.value_   rhs.value_);

    };


    auto operator (const Xamp; lhs, const Xamp; rhs)->decltype(lhs.value_   rhs.value_)
    {//If I change return type to "not auto" there is no problem with friendship
        return lhs.value_   rhs.value_;
    }

    int main(int argc, char* argv[])
    {
        X a(5);
        X b(6);
        cout << a   b;
        return 0;
    }
  

Не удается объявить дружбу с operator в сценарии, когда возвращаемый тип — auto. Есть решение для этого?

Это работает с g 4.5.1:

 class X {
   ...


    friend auto operator ( const X amp; a, const X amp; b )->decltype( X::value_   X::value_  );
};

auto operator ( const X amp; a, const X amp; b )->decltype( X::value_   X::value_) {
    return a.value_   b.value_;
}
  

Это похоже на ошибку компилятора, а не на что-то преднамеренное (какой компилятор? рассмотрите возможность подачи ошибки). Однако вы всегда можете использовать уродливую альтернативу, описанную в спецификации для auto с функциями (конечно, отказ от этого является мотивацией для нового синтаксиса, но если это не сработает …), а именно:

 decltype((*(X*)0).value_   (*(X*)0).value_)
  

У вас одинаковый X с обеих сторон, поэтому вы можете создать typedef в X, чтобы вам не приходилось вводить эту неприятность как в объявлении, так и в определении оператора.

(Редактировать) В случаях, когда у вас нет одинакового X с обеих сторон, вы все равно можете учесть объявление, чтобы оно не было слишком ужасным, подготовив шаблон (признак) с decltype и используя его для объявления оператора. Что-то вроде:

 template <typename X, typename Y>
struct PlusType {
    typedef decltype((*(X*)0).value_   (*(Y*)0).value_) Type;
}

template <typename X, typename Y>
PlusType<X, Y>::Type operator (X amp;x, Y amp;y);
  

На мой взгляд, в вашей ситуации использование auto не имеет особого смысла, вам, вероятно, было бы лучше сказать, что оператор возвращает int .

Проблема здесь в том, что для того, чтобы иметь возможность писать rhs.value_ rhs должен быть экземпляром полного типа. Тип X считается завершенным после закрытия } класса. Так что компилятор справедливо жалуется.

ПРАВКА3:

Поскольку мне кажется, что мое приведенное выше объяснение не было полным и могло привести к путанице.

 struct X
{

   //code ommited for brevity...
   //at this line one has decltype(lhs.value_   rhs.value_) where 
   //lhs and rhs are of type X however the X type is not yet complete. 
   //The compiler has to however determine the type of the friend including 
   //the return type...
   friend auto operator (const Xamp; lhs, const Xamp; rhs)-> decltype(lhs.value_   rhs.value_);
};
  

Редактировать:

Обсуждение VS2010, связанное с decltype, которое объясняет, почему это так, как в VS2010, а также объясняет, почему это стандартная компиляция, как это в VS2010, вы можете посмотреть здесь:

Моим первым вариантом было бы отказаться от auto. Однако, предполагая, что вы предоставили более простой пример для иллюстрации, и в вашем реальном случае auto действительно имело бы смысл, вы могли бы попробовать:

 struct X
{
private:
    int value_;
public:
    X() : value_(int()) { }

    X(int value):value_(value) { }

    template <typename T>
    auto operator (const Tamp; rhs) -> decltype(value_   rhs.value_)
    {
        return value_   rhs.value_;
    }
};

int main(int argc, char* argv[])
{
    X a(5);
    X b(6);
    std::cout << a   b;

    return 0;
}
  

ПРАВКА2:

Для полноты (и чтобы проиллюстрировать, что это не проблема с auto и friend, а скорее попытка использовать неполный тип, рассмотрим следующий код (который также достигает желаемого, но искаженным, не рекомендуемым способом :-)):

 #include <iostream>

struct X
{
public:
        X() : value_(int())     { }

        X(int value):value_(value) { }

        int value_;

};

struct A : public X
{
        friend auto operator (const Xamp; lhs, const Xamp; rhs) -> decltype(lhs.value_   rhs.value_);
};

auto operator (const Xamp; lhs, const Xamp; rhs) -> decltype(lhs.value_   rhs.value_)
{
        return lhs.value_   rhs.value_;
}

int main(int argc, char* argv[])
{
        X a(5);
        X b(6);
        std::cout << a   b;

        return 0;
}
  

Код нормально компилируется в VS2010 и gcc-4.5.1