C++ 将许多函数声明为类的朋友

如何方便地将多个模板函数声明为模板类的友元函数

例如：

template <typename T>
void funct1(MyClass<T> & A); //1.forward declaration.

template <typename T>
class MyClass{
    protected:
    T a;
    friend funct1(MyClass<T> & A); //2.declare friend
}
template <typename T>
void funct1(MyClass<T> & A){ //3.actual implementation
    ++A.a;
}

模板
无效功能1（MyClass&A）//1.远期申报。
模板
类MyClass{
受保护的：
Tα；
friend funct1（MyClass&A）；//2.声明friend
}
模板
void funct1（MyClass&A）{//3.0实际实现
++A.A；
}

对于许多函数中的每一个，重复步骤1、2、3

---

是否可以将所有这些函数组合成某个对象，然后声明其中的所有内容都是模板类的朋友？

是的！您可以使它们成为

类的
静态成员函数，并使该
类成为
朋友

template <typename T>
class MyClass{
    protected:
    T a;
    friend class MyFunctions;
}

模板
类MyClass{
受保护的：
Tα；
朋友类MyFunctions；
}
是！您可以使它们成为
类的
静态成员函数，并使该
类成为
朋友

template <typename T>
class MyClass{
    protected:
    T a;
    friend class MyFunctions;
}

模板
类MyClass{
受保护的：
Tα；
朋友类MyFunctions；
}
一个friend类怎么样，所有函数都可以进入该friend类：

#include <iostream>

using namespace std;

template <typename T>
class MyFriend;

template <typename T>
class MyClass{
    protected:
      T a;
    public:
      MyClass(T _a):a(_a) {}

    friend MyFriend<T>;
};

template <typename T>
class MyFriend {
  public:
  void funct1(MyClass<T> &A) {
    ++A.a;
    cout << "A.a: " << A.a << endl;
  }

  void funct2(MyClass<T> &B) {
    B.a +=  2;
    cout << "A.a: " << B.a << endl;
  }

};

int main() {
  MyClass<int> myclass(0);
  MyFriend<int> myfriend;

  myfriend.funct1(myclass);
  myfriend.funct2(myclass);

  return 0;
}

#包括
使用名称空间std；
模板
班上我的朋友；
模板
类MyClass{
受保护的：
Tα；
公众：
MyClass（T_a）：a（_a）{}
朋友我的朋友；
};
模板
班级我的朋友{
公众：
无效函数1（MyClass&A）{
++A.A；
cout一个friend类怎么样，所有函数都可以进入该friend类：

#include <iostream>

using namespace std;

template <typename T>
class MyFriend;

template <typename T>
class MyClass{
    protected:
      T a;
    public:
      MyClass(T _a):a(_a) {}

    friend MyFriend<T>;
};

template <typename T>
class MyFriend {
  public:
  void funct1(MyClass<T> &A) {
    ++A.a;
    cout << "A.a: " << A.a << endl;
  }

  void funct2(MyClass<T> &B) {
    B.a +=  2;
    cout << "A.a: " << B.a << endl;
  }

};

int main() {
  MyClass<int> myclass(0);
  MyFriend<int> myfriend;

  myfriend.funct1(myclass);
  myfriend.funct2(myclass);

  return 0;
}

#包括
使用名称空间std；
模板
班上我的朋友；
模板
类MyClass{
受保护的：
Tα；
公众：
MyClass（T_a）：a（_a）{}
朋友我的朋友；
};
模板
班级我的朋友{
公众：
无效函数1（MyClass&A）{
++A.A；
为什么会有这么多的朋友函数？也许你应该重新考虑你的设计。我正在为n维数组之间的数学编写一个小库。myclass是一个n维数组对象。这些函数是在nArray上工作的许多数学运算。也许我可以把所有的函数都转换成nArray对象的方法。嗯。但是我et类似于A.sin（）而不是sin（ndarray A）。这感觉有点奇怪。也许您应该通过
迭代器
或
运算符[]公开数组的元素
。简单地让函数成为朋友不是一个好主意。否则，每次添加新函数时，都必须修改
MyClass
。如何实现快速迭代器/运算符[]？到目前为止，我一直在使用一个指向内存的内部原始指针，并且具有正确的simd对齐方式。
运算符[]
非常简单，只返回给定索引处的元素引用（您可以以实现
std:：vector
为例）。一个好的编译器应该内联这些函数。所以它应该和原始指针操作一样快。为什么有这么多的朋友函数？也许你应该重新考虑你的设计。我正在为n维数组之间的数学编写一个小库。myclass是一个n维数组对象。这些函数是许多在ndar上工作的数学操作可能我可以将所有函数都转换成ndarray对象的方法。嗯。但是我得到了类似于A.sin（）的东西，而不是sin（ndarray A）。这感觉有点奇怪。也许你应该通过
迭代器
或
操作符[]来公开数组的元素
。简单地让函数成为朋友不是一个好主意。否则，每次添加新函数时，都必须修改
MyClass
。如何实现快速迭代器/运算符[]？到目前为止，我一直在使用一个指向内存的内部原始指针，并且具有正确的simd对齐方式。
运算符[]
非常简单，只返回给定索引处的元素引用（您可以以
std:：vector
的实现为例）。一个好的编译器应该内联这些函数。因此它应该与原始指针操作一样快。