Question

我有一个程序，它有一个类Hook executed successfully but returned HTTP 500 missing_text_or_fallback_or_attachments的单个实例和类class A的许多实例，其中class B的每个实例都有一个指向{的单个实例的指针{1}}。我以为我可以在class B中启动它们，然后将class A的单个实例的地址传递给main()的所有实例。我想知道这是否正确，我一直在寻找继承，但是从我的理解（这通常是错误的），如果你继承了另一个类，那么每次启动该类都会创建一个多对多的关系，而我想要一个太多。我附上了一些代码。任何建议都将不胜感激。

class A

Answer 1

在下面的函数中违反了您只想创建一个A实例并使用指向该A实例的指针的意图。

void assign_pointer(A class_a_to_assign) {
    class_a = &class_a_to_assign; // assign the pointer the address to point to
}

由于您按价值接受class_a_to_assign，因此您有两个问题：

每次调用该函数时，您都在创建A的新实例。
您正在存储指向临时对象的指针。一旦函数返回，指针就变为无效指针。

您可以通过将参数设置为引用类型来解决这两个问题。

void assign_pointer(A& class_a_to_assign) {
    class_a = &class_a_to_assign; // assign the pointer the address to point to
}

此外，正如评论中所提到的，最好在A对象之前创建B对象，因为您希望A比B更长久对象。

int main() {
    cout << "hello world" << endl;

    // create 1 instance of A
    A a1;

    // create 2 instances of B there could be thousands of these tho.
    B b1;
    B b2;

    ...
}

Answer 2

首先，您的代码中存在严重问题：

void assign_pointer(A class_a_to_assign) {
    class_a = &class_a_to_assign; // assign the pointer the address to point to
}

这里，class_a_to_assign是一个按值函数参数，它的生命周期与任何函数局部变量大致相同。换句话说，只要控制离开方法的范围，class_a就会变成悬空指针（指向不再存在的本地对象的指针）。 quickfix简单明了：

void assign_pointer(A &class_a_to_assign) {
    class_a = &class_a_to_assign; // assign the pointer the address to point to
}

区别仅在于单个字符 - 函数＆amp;参数声明中的＆符号将其从临时值转换为对更长寿命对象的引用。

接下来，如果您有一个class A的单个对象，您是否考虑将其设为单身？这样，B的实例甚至不需要保留该指针，A本身就可以管理实例。在那里有很多关于设计单例类的说法，原始和天真的实现类似于：

class A {
    A(); // note it's private
public:
    int getValue() const;
    static A &instance() {
        static A retVal;
        return A;
    };
};

class B {
public:
    void update_my_value(void) {
        value_b += A::instance().get_value();
    }
};

int main() {
    A::instance(); // to warmup the static instance before any users are created
    B b1; // no assign_pointer is needed as A is a Singleton
    B b2; // and every B always knows where to find it
}

Answer 3

你所描述的内容听起来很像singleton。通常处理的一种方法是让单例类包含一个返回类的单个实例的static方法。所以它看起来像这样：

class A {
    public:
        A() { /* constructor */ }
        ~A() { /* destructor */ }
        static A* getInstance();
        double get_value(void) {
            return value;
        }
    private:
        double value;
};

static方法将在实现（.cpp）文件中看起来像这样：

static A gSharedInstance;

static A* A::getInstance()
{
    return &gSharedInstance;
}

这在静态初始化时构造A，当调用上述方法时，它返回指向该静态共享实例的指针。现在，只要您想使用A，就可以执行以下操作：

A* sharedA = A::getInstance();
double value = sharedA->getValue(); // Or whatever you need from it.

请注意，单例本质上是一个全局变量，全局变量存在一些问题。（例如，在这种情况下，它的value成员设置在哪里？）但是如果该类代表一些真正独特的资源（例如设备上唯一的麦克风），那么值得用一个单例表示它。在这种情况下，最好将其设为只读，以便不能在许多不同的地方设置其状态。另外，请注意，您可能需要添加代码来处理同时访问它的多个线程。

C ++通过函数初始化类指针

3 个答案: