Question

我有一个线程类缓冲区（自己创建的类），以及许多派生类，例如 BufferTypeA ， BufferTypeB ... < / p>

由于我必须按特定顺序同步它们，所以我给它们中的任何一个整数来表示运行某个任务的顺序。我还必须知道每个线程缓冲区中哪个是下一个运行任务，所以我传递每个BufferType一个整数的引用，所有这些都必须共享，我不想让它成为全局。

我在任何时候都迷路了，我看不到。

首先，我从一个类创建所有BufferTypes，我也将该共享整数定义为：

int currentThreadOrder;

创建BufferTypes时：

int position = 0;
    if (NULL == bufferA) {
            bufferA = new BufferTypeA(&currentThreadOrder, ++position,
                        waitCondition);
        }
        if (NULL == bufferB) {
            bufferB = new BufferPos(&currentThreadOrder, ++position,
                        waitCondition);
        }
        if (NULL == bufferC) {
            bufferC = new BufferRtk(&currentThreadOrder, ++position,
                        waitCondition);
        }

然后，在BufferTypeA标题中：

class BufferTypeA: public Buffer {
public:
    BufferTypeA(int currentThreadOrder,
            int threadConnectionOrder = 0,
            QWaitCondition *waitCondition = NULL);
//..
}

在cpp文件中：

BufferTypeA::BufferTypeA(int currentThreadOrder, int threadConnectionOrder, QWaitCondition *waitCondition):
        Buffer(currentThreadOrder, threadConnectionOrder, waitCondition) { }

现在我将显示Buffer header：

    class Buffer: public QThread {
    public:
        Buffer(int &currentThreadOrder,
                int threadConnectionOrder = 0,
                QWaitCondition *waitCondition = NULL);
    //...
protected:
    QWaitCondition *waitCondition;
    int threadConnectionOrder;
    int &currentThreadOrder; // Shared address
    }

最后是cpp：

Buffer::Buffer(int &currentThreadOrder, int threadConnectionOrder, QWaitCondition *waitCondition) {

    this->threadConnectionOrder = threadConnectionOrder;
    this->waitCondition = waitCondition;
    this->currentThreadOrder = currentThreadOrder;
}

我得到的错误是错误：未初始化的参考成员 Buffer :: currentThreadOrder 。

我很尴尬地问，因为这会是指针和地址的一个简单问题，但我看不出问题所在，所以请帮助。

Answer 1

当您使用作为引用的数据成员创建类时，需要在构造函数初始值设定项列表中为引用分配一个值。

引用必须在创建时赋予值，它们不是指针。它们必须以值开头，并且该值不能更改（同时可以更改该值指向的内容）。

基本上，您可以将引用视为现有变量的别名。 如果你没有朋友，你就不能给朋友一个昵称：）

回应评论：

你没有＆＃t;共享参考＆＃34;对象之间。每个对象都有自己对同一变量的引用。当你通过参考＆＃34;通过＆＃34;您告诉编译器您希望函数中的变量实际上是外部作用域中的变量，而不是按值创建新变量。这意味着您在一个内存位置只有一个变量。引用只是将其转发到同一内存位置的其他地方的内存。

将此视为呼叫转移...我可以在15个不同的国家/地区拥有15个电话号码。我可以将它们全部设置为将呼叫转发到我在美国的小区。所以，无论他们打电话给谁，人们都会打电话给我。

您的每个课程都有另一个参考来转发＆＃34;电话＆＃34;或变量读/写到同一个内存位置。因此，您并未在类之间共享引用，而是确保每个类都具有对相同底层内存位置的引用。

回到比喻，每个班级都没有同一部手机，但是每个班级都有。手机将转发到相同的数字（变量），让它们最终设置/获得相同的值。

回应II：

这是一个简单的例子让你的头脑开始，它很容易适用于你的课程。我没有编译它，但它应该可以减去一两个错字。

class A
{
    public:
        A(int& shared) : m_shared(shared)
        {
            //No actions needed, initializer list initializes
            //reference above. We'll just increment the variable
            //so you can see it's shared in main.
            m_shared += 7;
        }

        void DoSomethingWithIt()
        {
            //Will always reflect value in main no matter which object
            //we are talking about.
            std::cout << m_shared << std::endl;
        }            

    private:

        //Reference variable, must be initialized in 
        //initializer list of constructor or you'll get the same
        //compiler error again.
        int& m_shared;
};

int main()
{
    int my_shared_integer = 0;

    //Create two A instances that share my_shared_integer.
    //Both A's will initialize their internal reference to
    //my_shared_integer as they will take it into their
    //constructors "by reference" (see & in constructor
    //signature) and save it in their initializer list.
    A myFirstA(my_shared_integer);
    A mySecondA(my_shared_integer);

    //Prints 14 as both A's incremented it by 7 in constructors.
    std::cout << my_shared_integer << std::endl;
}

Answer 2

你将指针int*作为第一个参数传递给BufferTypeA，期望和int，而你在问题中说你打算使用int&。要做到这一点，BufferTypeA的ctor应该使用int&并在初始化列表中初始化它（即不在ctor的{ }部分内），如

class BufferType {
  int &Ref;
public:
  BufferTypeA(int& ref) : Ref(ref) { /* ... */ }
};

在你BufferA的构造中，你不能传递地址，而是引用，即

int counter;
Buffer = new BufferType(counter);

Answer 3

你想要这样的代码：

Buffer::Buffer(
    int &currentThreadOrder0,
    const int threadConnectionOrder0,
    QWaitCondition *const waitCondition0
) :
  threadConnectionOrder(threadConnectionOrder0),
  waitCondition(waitCondition0),
  currentThreadOrder(currentThreadOrder0)
{}

原因与你不能写

的原因有关

const double pi;
pi = 3.14;

但可以写

const double pi = 3.14;

引用通常实现为常量指针，在初始化指针之后无法为其分配地址。您的代码版本分配，与第一个pi示例中一样。我的代码版本初始化，与第二个pi示例一样。

通过引用将整数传递给c ++中的类

3 个答案: