C++ C++；具有常量构造函数参数的变量构造函数方法

我试图在类构造函数中使用函数指针，以便选择用于构造类对象的函数。我想这样做是为了能够改变如何使用同一组构造函数参数确定类中的成员变量的方法。我已经能够成功地编写此代码，如下面的代码所示，但是我需要声明所有指向好友的单独函数

我的问题：有没有办法将一个名称未知（即只知道返回类型和一组参数）的函数声明为友元？我这样做是因为在未来的开发中可能会添加新函数，而类保持不变，我不想为每个新函数添加新的友元声明

当然，我也愿意用其他方法来实现我的目标

#include <iostream>

class foo
{
private:
    int var_1;
public:
    foo(void (*functionPtr)(foo*))
    {
        functionPtr(this);
    }
    ~foo(){}

    int get_var() {return var_1;}

    friend void function_1(foo*); // declare all unique
    friend void function_2(foo*); // functions as friends

    /*friend void (*functionPtr)(foo*); // this is what I want:
                                        // to declare all functions with
                                        // a specific return type and
                                        // specific arguments as a friend
                                        // of this class */
};

void function_1(foo* T)
{
    std::cout << "function 1" << std::endl;
    T->var_1 = 1;
}

void function_2(foo* T)
{
    std::cout << "function 2" << std::endl;
    T->var_1 = 2;
}

int main()
{
    foo F1(&function_1);
    std::cout << F1.get_var() << std::endl;

    foo F2(&function_2);
    std::cout << F2.get_var() << std::endl;

    return 0;
}

#包括
福班
{
私人：
int var_1；
公众：
foo（无效（*functionPtr）（foo*））
{
函数ptr（this）；
}
~foo（）{}
int get_var（）{return var_1；}
friend void函数_1（foo*）；//声明所有函数都是唯一的
friend void function_2（foo*）；//作为朋友的函数
/*friend void（*functionPtr）（foo*）；//这就是我想要的：
//用
//特定的返回类型和
//作为朋友的具体论点
//这一类的*/
};
无效函数_1（foo*T）
{
std:：cout您可以将要初始化的部件移动到一个单独的地方，在那里它们被认为是公共的：

struct foovars
{
    int var_1;
};

class foo : foovars
{
public:
    foo(void (*functionPtr)(foovars*))
    {
        functionPtr(this);
    }
};

void function_1(foovars* T)
{
    std::cout << "function 1" << std::endl;
    T->var_1 = 1;
}

struct foovars
{
int var_1；
};
foo类：foovars
{
公众：
foo（无效（*functionPtr）（foovars*））
{
函数ptr（this）；
}
};
无效函数_1（foovars*T）
{
std:：coutStatic
class
函数在这里工作得更好：

class foo
{
private:
    int var_1;
public:
    foo(void (*functionPtr)(foo*))
    {
        functionPtr(this);
    }
    ~foo(){}

    int get_var() {return var_1;}

    static void function_1(foo*); // declare all unique
    static void function_2(foo*); // functions as friends

};

void foo::function_1(foo* T)
{
    std::cout << "function 1" << std::endl;
    T->var_1 = 1;
}

void foo::function_2(foo* T)
{
    std::cout << "function 2" << std::endl;
    T->var_1 = 2;
}


int main()
{
    foo F1(&foo::function_1);
    std::cout << F1.get_var() << std::endl;

    foo F2(&foo:function_2);
    std::cout << F2.get_var() << std::endl;

    return 0;
}

class-foo
{
私人：
int var_1；
公众：
foo（无效（*functionPtr）（foo*））
{
函数ptr（this）；
}
~foo（）{}
int get_var（）{return var_1；}
静态void函数_1（foo*）；//声明所有函数都是唯一的
静态void函数_2（foo*）；//用作朋友
};
void foo:：函数_1（foo*T）
{
在这种情况下，使用标记分派。它（更）易于维护，并将产生更高效的代码

#include <iostream>

class foo
{
private:
    int var_1;
public:
    struct type1_type {}; static constexpr type1_type type1{};
    struct type2_type {}; static constexpr type2_type type2{};

    foo(type1_type)
    : var_1(1)
    {
        // initialisation for type 1 construction
    }

    foo(type2_type)
    : var_1(2)
    {
        // initialisation for type 2 construction
    }

    ~foo(){}

    int get_var() {return var_1;}


};

int main()
{
    foo F1(foo::type1);
    std::cout << F1.get_var() << std::endl;

    foo F2(foo::type2);
    std::cout << F2.get_var() << std::endl;

    return 0;
}

我太老了，生疏了，不能详细地考虑这个问题，但要研究访问者的模式。“我想这样做是为了……”-不，你不知道，儿子。你要做的是明确定义你的需求，然后看看哪种语言功能可以正确建模。正如芭丝谢芭所注意到的那样，你可能想为此采用一种模式。我建议你也看看工厂模式。感谢你的建议，我将尽可能了解这两种模式：工厂模式模式仍然要求将函数添加到代码中，我希望保持不变。访客模式似乎在升级，但与下面John Zwinck的答案相比，实现起来相当复杂。这需要在每次添加新函数时修改类定义。我解释任务的方式ion认为这是不可接受的，否则，
friend
方法会起作用。你不应该鼓励这种可怕的反模式。你将对下一代垃圾代码负责。正如John所说，这确实为我想要保留的类增加了更多unchanged@Sjonnie：不客气。如果这个答案解决了你的问题，请认罪SE考虑通过单击左边的复选标记来“接受”。如果变量具有公共接口，为什么我们不将它们封装并使用复制语义传递它们？这将更加清晰和高效。这需要在添加新函数时更改类本身，这正是我在这里试图避免的。
1
2