c++ - 如何初始化对 std::ofstream 的静态引用？

Question

我有一个公共成员的班级 Cl

static std::ofstream &_rout;

在主文件中

ofstream out("output.txt");
ofstream& Cl::_rout(out);

但是我有一个编译错误：非法定义或重新定义。我该如何纠正？

Answer 1

尝试这个。

记录器.h

#include <string>
#include <fstream>
#include <iostream>

using namespace std;

class Logger{

    public:
            static void open( const string & logFile);
            static void close();
            // write message
            static void write( const string & message);

    private:
          Logger();
          ofstream fileStream;
          //Logger instance (singleton)
          static Logger instance;
};

记录器.cpp

#include "Logger.h"

Logger Logger::instance;

Logger::Logger(){}

void Logger::open( const string& logFile){
   instance.fileStream.open(logFile.c_str());
}
void Logger::close(){
    instance.fileStream.close();

} 
void Logger::write(const string& message){
    ostream& stream =  instance.fileStream ;
    stream << message<< endl;
}

主文件

#include "Salida/Logger.h"
int main(){
    Logger::open(path);
    Logger::write("text");
    Logger::close();
    return 0;

}

Answer 2

您只能在静态/全局范围内设置引用

#include<CL.h>
ofstream& Cl::_rout(out);
int main() {
  // ...
}

在声明（和初始化）后无法重新设置引用。您可以通过使用指针而不是引用来实现您的目标：

class Cl {
  static std::ofstream* _rout;
};
std::ofstream* CL::_rout = NULL;

int main() {
  ofstream out("output.txt");   
  Cl::_rout = &out;   
}

请注意，指针仅out在超出范围之前才有效。如果这是一个问题，请动态分配内存：

  ofstream* out = new ofstream("output.txt");   
  Cl::_rout = out;   

delete当您不再需要对象时不要忘记它以避免内存泄漏

Answer 3

好吧，您可以使用以下方法：

#include <fstream>

class CI
{
public:
  static std::ofstream &_rout;
};

static std::ofstream out("output.txt");

std::ofstream& CI::_rout = out;

int main()
{
}

然而，问题在于输出文件的名称是固定的（硬编码到程序中）。

我建议您使用指针而不是引用：

#include <cstddef>
#include <fstream>

class CI
{
public:
  static std::ofstream *_rout;
};

std::ofstream* CI::_rout = NULL;

int main()
{
  const char *output_file = "output.txt";
  std::ofstream out(output_file);
  CI::_rout = &out;
}