Question

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

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

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

#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;
}

Answer 1

您可以将要初始化的部分移动到一个单独的位置，将其视为公共部分：

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;
}

现在，您的成员变量与以前一样私有，从持有class foo实例的代码的角度来看。但是，设法接收foovars*的特殊功能可以修改其成员。

Answer 2

静态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;
}

由于他们是班级成员，因此不需要friend，他们可以完全访问班级的private成员。

更好的是，static函数可以是private，并且在课堂外无法访问。

Answer 3

在这种情况下，请使用标签调度。它（更多）更易于维护，并将产生更高效的代码。

#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;
}

预期结果：

1
2

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

3 个答案: