标签: friend-function

考虑以下代码:

namespace foo {}

class A
{
   class B
   {
   };

   friend int foo::bar( B& );
};

namespace foo
{
   int bar( A::B& )
   {
   }
}

G ++ 4.4.3告诉我:

friendfun-innerclass.cpp:21:错误:'int foo :: bar(A :: B&)'应该在'foo'中声明

但我无法宣布:

namespace foo
{
   int bar( A::B& );
}

在A类定义之前因为A :: B尚未声明.而且我不能明确声明"A类:: B",声明类BI必须给出类A的定义,据我所知,"朋友"声明必须在A类的定义中.

对我来说很奇怪的是,如果我从命名空间foo中取出函数"bar()",一切正常.对我来说似乎违反直觉的是,在命名空间内部或不在命名空间内部使用函数会改变编译器是否接受类中的友元函数声明.

有没有人知道如何通过这种方式来构建所有声明并使其发挥作用？

为什么下面的代码用g ++编译好但是在clang上得到错误？

#include <iostream>

class Object {};

class Print
{
public:
    template <typename CharT>
    inline friend std::basic_ostream<CharT> & operator<<(std::basic_ostream<CharT> & out, const Object&)
    {
        return (out << "object");
    }
    static void f( const Object& str )
    {
        std::cout << str;
    }
};

int main()
{
    std::cout << Object() << std::endl;
    return 0;
}

证明链接:g ++/clang ++

当我将友元函数移动到全局命名空间时,为两个编译器编译好的代码(clang ++/g ++).

在这种情况下,哪种实现更兼容C++ Standart？

我最近发现朋友声明范围遵循极其特殊的规则 - 如果你有一个friend函数或一个尚未声明的类的声明(定义),它会在直接封闭的命名空间中自动声明(定义),但它是不可见的不合格和合格的查询; 但是,友元函数声明通过依赖于参数的查找保持可见.

struct M {
    friend void foo();
    friend void bar(M);
};

void baz() {
    foo();    // error, unqualified lookup cannot find it
    ::foo();  // error, qualified lookup cannot find it
    bar(M()); // ok, thanks to ADL magic
}

如果你看一下标准(参见链接的答案),他们就会付出很大的代价来启用这种古怪的行为,在复杂规则的限定/非限定查找中添加一个特定的例外.最终的结果让我感到非常困惑¹,还有另一个案例要添加到实现中.作为

• 要求friend声明引用现有名称,期限; 要么
• 允许他们像现在一样声明东西,但不改变普通的名字查找(因此,这样的名称变得可见,好像在封闭的命名空间中声明为"正常")

似乎更容易实现,指定,最重要的是,理解,我想知道:为什么他们为这个烂摊子烦恼？他们试图覆盖哪些用例？在任何这些更简单的规则下(特别是第二个与现有行为最相似的规则)会破坏什么？

1. 例如,在这种特殊情况下

   struct M {
      friend class N;
   };
   N *foo;
   typedef int N;
   

   Run Code Online (Sandbox Code Playgroud)

   你得到可笑的精神分裂症错误信息

   <source>:4:1: error: 'N' does not name …

   Run Code Online (Sandbox Code Playgroud)

最小的例子:

class A
{
    friend void swap(A& first, A& second) {}
    void swap(A& other) {}
    void call_swap(A& other)
    {
        swap(*this, other);
    }
};

int main() { return 0; }

g ++ 4.7说:

friend.cpp: In member function ‘void A::call_swap(A&)’:
friend.cpp:7:20: error: no matching function for call to ‘A::swap(A&, A&)’
friend.cpp:7:20: note: candidate is:
friend.cpp:4:7: note: void A::swap(A&)
friend.cpp:4:7: note:   candidate expects 1 argument, 2 provided

退出第4行:

// void swap(A& other) {}

......它工作正常.如果我想保留交换功能的两种变体,为什么以及如何解决这个问题？

我与中描述的问题挣扎了这个问题(声明一个模板函数作为模板类的朋友),我相信第二个答案就是我想要做的(向前声明模板函数,然后将其命名一个专门为好友).我有一个问题,一个稍微不同的解决方案是否实际上是正确的,或者只是恰好在Visual C++ 2008中工作.

测试代码是:

#include <iostream>

// forward declarations
template <typename T>
class test;

template <typename T>
std::ostream& operator<<(std::ostream &out, const test<T> &t);

template <typename T>
class test {
  friend std::ostream& operator<< <T>(std::ostream &out, const test<T> &t);
  // alternative friend declaration
  // template <typename U>
  // friend std::ostream& operator<<(std::ostream &out, const test<T> &t);

  // rest of class
  };

template <typename T>
std::ostream& operator<<(std::ostream &out, const test<T> &t) {
  // output function defined here
  }

首先,我发现一个奇怪的事情是,如果我更改前向声明operator<<以使其不匹配(例如std::ostream& …

跟随2019 年特拉维夫欧洲电视网的捷克歌曲

class A {
public:    
    // forward declaration
    class Inner2;

private:
    class Inner1 {
        char foo;
        friend class Inner2;
    };
public:
    class Inner2 {
        Inner1 i;
    public:
        bool operator==(Inner2 other) {
            return i.foo == other.i.foo; // OK by GCC, Clang and MSVC++
        }
        friend bool operator!=(Inner2 a, Inner2 b) {
            return a.i.foo != b.i.foo; // Clang accepts, GCC and MSVC++ reject
        }
    };
};