我并不想让标题过于复杂，但我设计的东西比我指出的要复杂得多。该代码几乎类似于以下内容，至少在基本原则上如此。
template<output_stream>
class logger
{
output_stream streamer
}
using xlog = logger<x>
class singleton_manager
{
static int register_log(string x)
{
logs.pushback(x related thing)
return logs.size() - 1
}
static std::ostringstream(int index)
static std::vector<xlog> logs
}
class unrelated
{
static int logindex
void error()
}
int logindex = singleton_manager::register_log("simplest_example.log")
所以问题是，当我调用上面的行时，来自我的unrelated.cpp，register_log（）不会保留新的日志。
它运行方法..
创建新日志..
返回新日志的索引..
将返回的值赋给静态成员..
新日志实际上并不存在..
我唯一能理解的是，因为赋值是针对静态成员并使用单例的静态方法，所以它只是假装创建新日志。或者也许是因为模板？任何有关我的错误的输入都将非常感激。
编辑：你要求它。
#ifndef S3DMESH_H_
#define S3DMESH_H_
#include <vector>
#include <fstream>
#include <debug_toolset.h>
using std::vector;
using std::string;
using std::ifstream;
struct s3d_vertex
{
float array[8];
void Load(ifstream& file)
{
file >> array[0];
file >> array[1];
file >> array[2];
file >> array[3];
file >> array[4];
file >> array[5];
file >> array[6];
file >> array[7];
}
};
struct s3d_index
{
float array[3];
void Load(ifstream& file)
{
file >> array[0];
file >> array[1];
file >> array[2];
}
};
class s3d_mesh
{
private:
static int errorlog_index;
int total_indices;
int total_vertices;
string texture_file;
protected:
vector<s3d_index> Indices;
vector<s3d_vertex> Vertices;
public:
s3d_mesh(){}
s3d_mesh(string file_path);
void Load(string file_path);
};
#endif
#include "s3d_mesh.h"
#include <sstream>
#include <debug_toolset.h>
using std::stringstream;
int s3d_mesh::errorlog_index = dbg::FileLog_Mgr::RegisterNewLog(L"s3d_errors.log");
s3d_mesh::s3d_mesh(string file_path)
{
Load(file_path);
}
void s3d_mesh::Load(string file_path)
{
ifstream File_Handle;
File_Handle.open(file_path, std::ios::in);
try
{
File_Handle >> total_vertices;
for ( int i = 0; i < total_vertices; ++i )
{
s3d_vertex temp;
temp.Load(File_Handle);
Vertices.push_back(temp);
}
File_Handle >> total_indices;
for ( int i = 0; i < total_indices; ++i )
{
s3d_index temp;
temp.Load(File_Handle);
Indices.push_back(temp);
}
File_Handle >> texture_file;
File_Handle >> texture_file;
File_Handle >> texture_file;
File_Handle >> texture_file;
if ( File_Handle.fail() )
throw File_Handle.rdstate();
File_Handle.close();
}
catch ( ... )
{
dbg::FileLog_Mgr::Start();
LOGFILEX(errorlog_index, dbg::logERROR) << "\tS3D File - Critical Failure Loading";
dbg::FileLog_Mgr::Stop();
}
}
/*The MIT License (MIT)
Copyright (c) <2014> <Josh S, Cooper>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.*/
#ifndef _DBG_LOG_
#define _DBG_LOG_
#include "lib_linkers\dbglinker.h"
#include <assert.h>
#include <cstdio>
#include <vector>
#include <fstream>
#include <sstream>
#include <thread>
#include <functional>
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
#include <windows.h>
//#include <stdio.h>
/*
Function for grabbing the timestamps
Windows Version
*/
inline std::string NowTime()
{
const int MAX_LEN = 200;
char buffer[MAX_LEN];
if ( GetTimeFormatA(LOCALE_USER_DEFAULT, 0, 0,
"HH':'mm':'ss", buffer, MAX_LEN) == 0 )
return "Error in NowTime()";
char result[100] = { 0 };
//std::string result = "";
static DWORD first = GetTickCount();
/*result += buffer;
result += ".";
result += (long)first;*/
std::sprintf(result, "%s.%03ld", buffer, ((long)(GetTickCount() - first) % 1000));
return result;
}
#else
#include <sys/time.h>
inline std::string NowTime()
{
char buffer[11];
time_t t;
time(&t);
tm r = {0};
strftime(buffer, sizeof(buffer), "%X", localtime_r(&t, &r));
struct timeval tv;
gettimeofday(&tv, 0);
char result[100] = {0};
std::sprintf(result, "%s.%03ld", buffer, (long)tv.tv_usec / 1000);
return result;
}
#endif //WIN32
namespace dbg
{
//Enums representing the different log levels
// Implemented as bits in a Byte as to facilitate turning specific levels on and off with a #define macro
enum LogLevel
{
logFATAL = 1 << 0, logERROR = 1 << 1,
logWARNING = 1 << 2, logINFO = 1 << 3,
logDEBUG1 = 1 << 4, logDEBUG2 = 1 << 5,
logDEBUG3 = 1 << 6, logDEBUG4 = 1 << 7
};
//Forward declaration for friend statement
class FileLog_Mgr;
/*
Logger template class
Implemented with a built-in Object of the OutputPolicy class
Logger expects very little of this Policy class itself as its methods' only use of the
Output Object are where it is being overwritten with a new OutputPolicy object
REQUIRED are an operator= overload + copy constructor
*/
template <typename OutputPolicy>
class Logger
{
friend FileLog_Mgr;
public:
virtual ~Logger()
{
}
Logger(){}
Logger(const Logger& other)
{
Output = other.Output;
}
Logger& operator=(const Logger& other)
{
Output = other.Output;
return *this;
}
inline LogLevel& ReportingLevel()
{
static LogLevel reportingLevel = logDEBUG4;
return reportingLevel;
}
inline std::string ToString(LogLevel level)
{
switch ( level )
{
case logFATAL:
return "\t~FATAL~\t\t";
break;
case logERROR:
return "\tERROR: \t\t";
break;
case logWARNING:
return "WARNING: \t";
break;
case logINFO:
return "INFO:\t ";
break;
case logDEBUG1:
return "DEBUG1:\t\t";
break;
case logDEBUG2:
return "DEBUG2:\t\t ";
break;
case logDEBUG3:
return "DEBUG3:\t\t ";
break;
case logDEBUG4:
return "DEBUG4:\t\t ";
break;
}
}
inline std::ostringstream& Get(LogLevel level = logINFO)
{
buffer << std::endl << " - " << NowTime() << " - \t";
buffer << ToString(level);
return buffer;
}
protected:
std::ostringstream buffer;
OutputPolicy Output; //templated output
};
/*
*/
class FileStream_Policy
{
public:
virtual ~FileStream_Policy()
{
if ( file_stream.is_open() )
{
file_stream.close();
}
}
FileStream_Policy(){};
FileStream_Policy(const FileStream_Policy& other)
{
file_name = other.file_name;
}
FileStream_Policy& operator=(const FileStream_Policy& other)
{
file_name = other.file_name;
return *this;
}
inline std::ofstream& Stream()
{
if ( !file_stream.is_open() )
file_stream.open(file_name, std::ofstream::out);// | std::ofstream::app
return file_stream;
}
inline std::wstring& FileName()
{
return file_name;
}
protected:
std::ofstream file_stream;
std::wstring file_name;
};
//Type Definition for a File Log using Logger<FileStream_Policy>
using FileLog = Logger<FileStream_Policy>;
class FileLog_Mgr
{
public:
static std::ostringstream& Get(int index, LogLevel level)
{
try
{
return Logs[index].Get(level);
}
catch ( int exception )
{
assert("Indexed Log does not exist");
exit(-404);
}
}
static int RegisterNewLog(std::wstring file_name)
{
if ( !ThreadRunning )
{
for ( int i = 0; i < Logs.size(); ++i )
{
if ( Logs[i].Output.FileName() == file_name )
return -2;
}
FileLog newLog;
newLog.Output.FileName() = file_name;
Logs.push_back(newLog);
return Logs.size() - 1;
}
else
{
return -1;
}
}
static bool CheckIndex(int index)
{
if ( index >= 0 && index < Logs.size() )
return true;
return false;
}
static bool macroCheck(int index, LogLevel level)
{
if ( index >= 0 && index < Logs.size() )
{
if ( level > Logs[index].ReportingLevel() || !Logs[index].Output.Stream() )
return false;
return true;
}
return false;
}
static bool Start()
{
if ( WtL_Thread.joinable() )
return false;
ThreadRunning = true;
WtL_Thread = std::thread(&FileLog_Mgr::WriteToLogs);
std::this_thread::sleep_for(std::chrono::milliseconds(StartDelay));
return true;
}
static bool Stop()
{
if ( WtL_Thread.joinable() )
{
ThreadRunning = false;
WtL_Thread.join();
return true;
}
return false;
}
protected:
static std::vector<FileLog> Logs;
private:
virtual ~FileLog_Mgr()
{
Stop();
}
static bool ThreadRunning;
static int WriteInterval;
static int StartDelay;
static std::thread WtL_Thread;
static void WriteToLogs()
{
while ( ThreadRunning )
{
for ( int i = 0; i < Logs.size(); ++i )
{
Logs[i].Output.Stream() << Logs[i].buffer.str();
Logs[i].buffer.str("");
Logs[i].Output.Stream().flush();
}
std::this_thread::sleep_for(std::chrono::milliseconds(WriteInterval));
}
//There might be buffered data
for ( int i = 0; i < Logs.size(); ++i )
{
Logs[i].Output.Stream() << Logs[i].buffer.str();
Logs[i].buffer.str("");
Logs[i].Output.Stream().flush();
}
}
};
}
#ifndef LOG_MAX_LEVEL
#define LOG_MAX_LEVEL (dbg::logFATAL + dbg::logERROR + dbg::logWARNING + dbg::logINFO + dbg::logDEBUG1 + dbg::logDEBUG2 + dbg::logDEBUG3 + dbg::logDEBUG4 )
#endif
#define LOGFILEX(index, level) \
if ( level & ~LOG_MAX_LEVEL || !dbg::FileLog_Mgr::macroCheck(index, level) ); \
else dbg::FileLog_Mgr::Get(index, level)
#define LOGFILE1(level) \
if ( level & ~LOG_MAX_LEVEL || !dbg::FileLog_Mgr::macroCheck(0, level) ); \
else dbg::FileLog_Mgr::Get(0, level)
#define LOGFILE2(level) \
if ( level & ~LOG_MAX_LEVEL || !dbg::FileLog_Mgr::macroCheck(1, level) ); \
else dbg::FileLog_Mgr::Get(1, level)
#define LOGFILE3(level) \
if ( level & ~LOG_MAX_LEVEL || !dbg::FileLog_Mgr::macroCheck(2, level) ); \
else dbg::FileLog_Mgr::Get(2, level)
#define LOGFILE4(level) \
if ( level & ~LOG_MAX_LEVEL || !dbg::FileLog_Mgr::macroCheck(3, level) ); \
else dbg::FileLog_Mgr::Get(3, level)
#define LOGFILE5(level) \
if ( level & ~LOG_MAX_LEVEL || !dbg::FileLog_Mgr::macroCheck(4, level) ); \
else dbg::FileLog_Mgr::Get(4, level)
#endif
答案 0 :(得分：1)
正如评论中所讨论的，我无法真正运行您的代码，因为它不是一个最小的工作示例。但是在你尝试过之后，似乎是静态初始化顺序的问题。
替换
static std::vector<xlog> logs;
通过函数
static std::vector<xlog>& getLogs() {
static std::vector<xlog> logs;
return logs;
}
并在getLogs()中使用logs时使用register_log。所以，例如：
static int register_log(string x)
{
getLogs().push_back(x related thing);
return getLogs().size() - 1;
}
这将确保在推送任何内容之前构造向量。