Question

我有一些课Foo和Logger：

class Logger{/* something goes here */};
class Foo{
  Foo(Logger& logger);
  Logger& logger;
}

Foo::Foo(Logger& logger) : logger(logger)
{}

现在我想创建一个Foo类对象数组，其中所有引用Foo::logger都应该指向同一个Logger对象。我尝试了类似的东西（我需要堆栈和堆分配）：

Logger log (/* parameters */);
Foo objects [3] (log); // On stack
Foo* pObjects = new Foo [3] (log); // On heap

问题是两个版本都试图调用默认的构造函数Foo()，这是不存在的。另据我的理解，无法更改引用的引用变量。因此，对默认构造函数的临时调用以及稍后的循环中的初始化也无济于事。

那么：做正确的方法是什么？我是否需要使用指向Logger对象的指针？

Answer 1

您无法使用非默认构造函数初始化对象数组。但是，您可以使用如图所示的向量here（查看第一个回复）

对于堆，您可以执行以下操作：

Foo* pObjects[3];

for (int i = 0; i < 3; ++i) {
   pObjects[i] = new Foo(log);
}

Answer 2

您可以使用C ++ 11大括号初始化使用非默认构造函数初始化一个objecs数组：

class Logger{/* something goes here */};
class Foo{
public:
  Foo(Logger& logger);
private:
  Logger& logger;
};

Foo::Foo(Logger& logger) : logger(logger)
{}

<小时/> EDIT ：在C ++ 11中，您可以使用vector做您想做的事：

#include <vector>
class Logger{/* something goes here */};
class Foo{
public:
  Foo(Logger& logger) : logger(logger) {}
private:
  Logger& logger;
};

int main () {
  Logger log;
  std::vector<Foo>(3, log);
}

请注意，vector解决方案在C ++ 03中不起作用。在C ++ 03中，向量构造函数调用Foo::operator=。在C ++ 11中，它调用Foo::Foo(const Foo&)。

Answer 3

对于一般用途，我通常将记录器设为Singleton，因此只有一个记录器可以从所有组件访问。 http://en.wikipedia.org/wiki/Singleton_pattern

这也使Foo的构造函数更加简单。

class Logger
{
    public:
        static Logger& getInstance()
        {
            static Logger    instance;
            return instance;
        }

        public log(const std::string& txt) 
        {
            //do something
        }

    private:
        Logger() {}
        Logger(Logger const&);              // Don't Implement.
        void operator=(Logger const&); // Don't implement
 };

并在Foo中使用它：

 Logger::getInstance().log("test");

或

 Logger& logger = Logger::getInstance();
 logger.log("test");

（来自@Loki Astari的单身人士的学分：C++ Singleton design pattern）

如何在C ++中使用引用成员创建数组？

3 个答案: