Question

我有一个公共成员的Cl级

static std::ofstream &_rout;

在主档

中

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

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

Answer 1

您只能在静态/全局范围设置参考

#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 2

尝试一下。

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

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

main.cpp

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

}

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

如何初始化std :: ofstream的静态引用？

3 个答案: