Related
I'm using an external C API from C++, where functions report an error by setting a global error state that needs to be queried manually after each function call.
In order to avoid doing this manually each time I'm using a macro to wrap the function calls, which looks similar to this:
#define CHECK(_call_) \
do { \
_call_; \
int err = LastError(); \
if(err != 0) throw Error(err, __FILE__, __LINE__); \
} while(0)
used like CHECK(ExternalFct(1, 2, 3)).
But this does not work for functions that return a value. In order to support this, a solution that seemed to work is to create and call a temporary lambda, containing an object that checks the error in its destructor:
#define CHECK(_call_) \
([&] { \
struct ErrorChecker { \
~ErrorChecker() noexcept(false) { \
int err = LastError(); \
if(err != 0) throw Error(err, __FILE__, __LINE__); \
} \
} errorChecker; \
return _call_; \
}())
It uses the fact that return <expression> is allowed even if the expression is void.
This seems to work, but looks like it could cause problems, mainly due to the capture-all lambda (needed to allow local variables inside the call expression), and the destructor which throws exceptions.
Are there situations in which this construct would cause problems (or unnecessary overhead), and is there a better way to make a single CHECK() macro that would work with both void and non-void functions?
I like your variant better, but if you want to get rid of destructor, you can do:
#define CHECK(_call_) \
([&]<typename T = decltype(_call_)> { \
if constexpr (std::is_void_v<T>) { \
_call_; \
int err = LastError(); \
if(err != 0) throw Error{err, __FILE__, __LINE__}; \
return; \
} else { \
T result = _call_; \
int err = LastError(); \
if(err != 0) throw Error{err, __FILE__, __LINE__}; \
return result; \
} \
}())
If you stick with macros, I would suggest renaming CHECK() to something more like CHECK_NO_RETURN(), and then defining a separate macro to handle returns, ie:
#define CHECK_NO_RETURN(_call_) \
do { \
_call_; \
int err = LastError(); \
if(err != 0) throw Error(err, __FILE__, __LINE__); \
} while(0)
#define CHECK_THEN_RETURN(_call_) \
do { \
auto ret = _call_; \
int err = LastError(); \
if(err != 0) throw Error(err, __FILE__, __LINE__); \
return ret; \
} while(0)
CHECK_NO_RETURN(ExternalFct1(1, 2, 3));
CHECK_THEN_RETURN(ExternalFct2(1, 2, 3));
Otherwise, I would suggest changing CHECK() into a variadic template function instead, eg:
#include <type_traits>
template<typename R, typename... Args>
inline typename std::enable_if<!std::is_void<R>::value, R>::type
Check(R (&call)(Args...), Args... args)
{
R ret = call(args...);
int err = LastError();
if (err != 0) throw Error(err, __FILE__, __LINE__);
return ret;
}
template<typename... Args>
inline void Check(void (&call)(Args...), Args... args)
{
call(args...);
int err = LastError();
if (err != 0) throw Error(err, __FILE__, __LINE__);
}
Check(ExternalFct1, 1, 2, 3);
return Check(ExternalFct2, 1, 2, 3);
Online Demo
Alternatively, in C++17 and later:
#include <type_traits>
template<typename R, typename... Args>
inline auto Check(R (&call)(Args...), Args... args)
{
if constexpr (!std::is_void_v<R>)
{
R ret = call(args...);
int err = LastError();
if (err != 0) throw Error(err, __FILE__, __LINE__);
return ret;
}
else
{
call(args...);
int err = LastError();
if (err != 0) throw Error(err, __FILE__, __LINE__);
}
}
Online Demo
Could you please help to take a look into my case and give me your advice?
I wrote a simple c++ code on UNIX. If I compiled code with optimization, it got crashed at _Unwind_Resume. It run successfully if I compiled without optimization.
The code look like this:
date.h
pragma once
#include <string>
namespace Test
{
class Date
{
public:
std::string asString() const;
};
}
date.C
#include "date.h"
std::string Test::Date::asString() const
{
return std::string();
}
process.h
#pragma once
namespace Test
{
class Date;
class Process
{
public:
void operator()( );
private:
void attemptProcessing( const Test::Date& );
void firstValidation( const Test::Date& );
void secondValidation( const Test::Date& );
};
void doPostingProcess( );
}
process.C
#include <exception>
#include <iostream>
#include <sstream>
/*------------------------------------------------------------------------*/
void Test::Process::operator()()
{
try {
Test::Date date;
attemptProcessing( date );
} catch ( const std::exception& e ) {
std::cout << "ex: " << e.what() << std::endl;
}
}
void Test::Process::attemptProcessing( const Test::Date& d)
{
std::cout << "If remove this, crash does not happen: " << d.asString() << std::endl;
firstValidation( d );
}
void Test::Process::firstValidation( const Test::Date& d )
{
secondValidation( d );
}
void Test::Process::secondValidation( const Test::Date& d )
{
std::ostringstream o;
o << "If remove this, crash does not happen";
throw std::exception();
}
void Test::doPostingProcess( )
{
auto processAccount = Test::Process();
processAccount();
}
test_validation.C
#include "process.h"
#include "date.h"
#include <iostream>
#include "process.h"
int main( int argc, char const* argv[] )
{
try {
Test::doPostingProcess( );
} catch( std::exception ex ) {
std::cout << ex.what() << std::endl;
}
return 0;
}
When I compiled with optimization, the program was crashed. The compile command is:
/opt/developerstudio12.6/bin/CC -std=c++14 -xipo -xO4 +w -xildoff -D_POSIX_PTHREAD_SEMANTICS -g0 -xtarget=generic -xcache=generic -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 date.C process.C test_validation.C
However, with this compile command( without optimization) the program worked well:
/opt/developerstudio12.6/bin/CC -std=c++14 +w -xildoff -D_POSIX_PTHREAD_SEMANTICS -g0 -xtarget=generic -xcache=generic -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 date.C process.C test_validation.C
The print stack of core dump is:
core '/var/corefiles/core.dc2nix1d3v10.a.out.28170' of 28170: a.out
fedaec9c _lwp_kill (6, 0, 0, fed8e13c, ffffffff, 6) + 8
fed229c8 abort (2, 1, fef9f068, ffb40, fee25518, 0) + 110
fef8c22c _Unwind_Resume (22db8, 0, ff150e58, ff150b5c, ffbfd944, ffbfd718) + 58
000122b8 main (22c00, 12800, ffbfdcf4, 22db8, 20, ffbfdcf3) + 488
00011728 _start (0, 0, 0, 0, 0, 22870) + 108
Are you sure the main try/catch is actually catching?
I would better catch by reference as suggested by:
C++ catch blocks - catch exception by value or reference?
I suspect that you get an uncaught exception from the stream operations.
I am trying to use CUDA C for GPU computing, in particular matrix inversion problem. Meanwhile at the beginning of my code I have defined function. But, that seems to give me an error of "expected declation" at the line where I initiate "do".
I am new to C++ so haven't tried much.
#include<cublas_v2.h>
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#define cudacall(call)
do
{
cudaError_t err = (call);
if (cudaSuccess != err)
{
fprintf(stderr, "CUDA Error:\nFile = %s\nLine = %d\nReason = %s\n", __FILE__, __LINE__, cudaGetErrorString(err));
cudaDeviceReset();
exit(EXIT_FAILURE)
}
}
while (0);
"Expected Declaration"
Multi-line macros need to have a \ to indicate that they continue on the next line. I lined all of them up at the end; scroll to see them.
#define cudacall(call) \
do { \
cudaError_t err = (call); \
if (cudaSuccess != err) { \
fprintf(stderr, "CUDA Error:\nFile = %s\nLine = %d\nReason = %s\n", \
__FILE__, __LINE__, cudaGetErrorString(err)); \
cudaDeviceReset(); \
exit(EXIT_FAILURE) \
} \
} while (0);
In general, please avoid macros if you can. Use lambdas and higher-order functions instead:
template<class F>
void cudacall(F&& func) {
cudaError_t err = func();
if (cudaSuccess != err) {
fprintf(stderr, "CUDA Error:\nFile = %s\nLine = %d\nReason = %s\n",
__FILE__, __LINE__, cudaGetErrorString(err));
cudaDeviceReset();
exit(EXIT_FAILURE);
}
}
We can use it like this:
void dostuff() {
bool wasICalled = false;
cudacall([&]() {
// Code goes here
// We can access and modify local variables inside a lambda
wasICalled = true;
// Return the error
return cudaError_t{};
});
}
I've currently been using custom exceptions to achieve the goal of jumping through deeply nested function calls, to get to a specific function in the call chain. For example, consider the following code:
#include <iostream>
struct label {};
void B();
void C();
void D();
void A() {
return B();
}
void B() { // I want to jump to the level of the B function in the call-chain.
try {
return C();
}
catch(const label& e) {
std::cout << "jumped to b function" << std::endl;
}
}
void C() {
return D();
}
void D() {
throw label();
}
int main() {
A();
return 0;
}
Note however that the above example is extremely contrived, and is simply for illustration purposes. In my actual code, I'm using this technique in a recursive-decent parser to recover from syntactical errors. Also note that I'm not using exceptions to jump around to different functions, like a glorified goto. I'm using the custom exception to always jump to one specific function near the top of the call chain.
The above code does work fine, but reading some of the top posts on the question Are exceptions as control flow considered a serious antipattern? If so, Why? (on the Software Engineering site), suggested that using exceptions in such a manner as the above scenario does, is consider an anti-pattern, and there are usually better was to accomplish one's goal.
Is my usage of a custom exception above appropriate? If not, what is a more reasonable way to accomplish my goal while avoiding using exactions as a form control flow? (Also, although I tagged this question as c++ since that's what I'm writing my parser in, I suppose this is a more language-agnostic question.)
Part 1: - Nested Function Stack Calls With Exceptions.
This may not fit your particular or exact needs, however I'm willing to share this example as I think that it may provide some insight and that it is related to your current situation.
I have a set of classes that are integrated together that handle multiple common tasks. The following set of classes include BlockProcess, BlockThread, FileHandlers, ExceptionHandler, Logger and a Utility class. There are several files here and please keep in mind that this light weight project is targeted towards Windows and that I am using Visual Studio 2017 with pre compiled headers.
I'm sure one can strip out any windows dependent code easily and replace with their equivalent system, architecture & environment includes and functionality.
I am also using a namespace called demo that wraps all the classes & functions in this small project; any user should replace this namespace with their own namespace name.
The main purpose of this is the design process of how I typically handle exceptions when the stack calls are nested quite deep.
These sets of classes not only allow control of Logging information, warnings & errors to the console with different settings for different types of messages, but also gives the ability to log the contents to a file.
This type of construct is very handy and versatile while being in the process of developing 3D Graphics Applications which can become very intense in their code base.
I can not take full credit for this code as a majority of this was inspired and designed by Marek A. Krzeminski, MASc which can be seen here yet I believe that it is the concepts and the use of this code that is important.
Main Entry Point:
main.cpp
#include "stdafx.h"
#include "BlockProcess.h"
#include "Logger.h"
#include "Utility.h"
//struct label {}; // Instead of throwing this struct in D() I'm throwing the ExceptionHandler
void B();
void C();
void D();
void A() {
return B();
}
void B() {
using namespace demo;
try {
return C();
} catch ( ... ) {
std::ostringstream strStream;
strStream << __FUNCTION__ << " failed for some reason.";
Logger::log( strStream, Logger::TYPE_INFO );
Logger::log( strStream, Logger::TYPE_WARNING );
Logger::log( strStream, Logger::TYPE_ERROR );
Logger::log( strStream, Logger::TYPE_CONSOLE );
}
}
void C() {
return D();
}
void D() {
using namespace demo;
std::ostringstream strStream;
strStream << __FUNCTION__ << " failed for some reason.";
throw ExceptionHandler( strStream ); // By Default will log to file; otherwise pass false for second param.
}
int _tmain( int iNumArgs, _TCHAR* pArugmentText[] ) {
using namespace demo;
try {
Logger log( "logger.txt" );
A();
// Prevent Multiple Start Ups Of This Application
BlockProcess processBlock( "ExceptionManager.exe" );
if ( processBlock.isBlocked() ) {
std::ostringstream strStream;
strStream << "ExceptionManager is already running in another window." << std::endl;
throw ExceptionHandler( strStream, false );
}
Utility::pressAnyKeyToQuit();
} catch ( ExceptionHandler& e ) {
std::cout << "Exception Thrown: " << e.getMessage() << std::endl;
Utility::pressAnyKeyToQuit();
return RETURN_ERROR;
} catch ( ... ) {
std::cout << __FUNCTION__ << " Caught Unknown Exception" << std::endl;
Utility::pressAnyKeyToQuit();
return RETURN_ERROR;
}
return RETURN_OK;
}
As you can see from the images above I was able to generate a log file of the info, warnings, errors etc., and if you look at the 2 consoles they were running simultaneously and the 2nd or lower cmd window is throwing the exception since I used the BlockProcess class to manage only a single instance of this running application. This is a very versatile design. The messages or thrown errors are being generated.
Now if you do not want execution to stop because of a specific value of a variable, the return of a function, if statement etc. instead of throwing an ExceptionHandler you can easily just create an ostringstream object, populate it with the needed iformation and you can pass that to Logger with the default option of saving to the Log file turned on or passing false as the last param. You can even set what type of message through the logger's types.
So to answer your question if this is anti-pattern? I honestly do not think it is if you carefully design your project and know where & when to throw messages.
ExceptionHandler:
ExceptionHandler.h
#ifndef EXCEPTION_HANDLER_H
#define EXCEPTION_HANDLER_H
namespace demo {
class ExceptionHandler final {
private:
std::string strMessage_;
public:
explicit ExceptionHandler( const std::string& strMessage, bool bSaveInLog = true );
explicit ExceptionHandler( const std::ostringstream& strStreamMessage, bool bSaveInLog = true );
~ExceptionHandler() = default;
ExceptionHandler( const ExceptionHandler& c ) = default;
const std::string& getMessage() const;
ExceptionHandler& operator=( const ExceptionHandler& c ) = delete;
};
} // namespace demo
#endif // !EXCEPTION_HANDLER_H
ExceptionHandler.cpp
#include "stdafx.h"
#include "ExceptionHandler.h"
#include "Logger.h"
namespace demo {
ExceptionHandler::ExceptionHandler( const std::string& strMessage, bool bSaveInLog ) :
strMessage_( strMessage ) {
if ( bSaveInLog ) {
Logger::log( strMessage_, Logger::TYPE_ERROR );
}
}
ExceptionHandler::ExceptionHandler( const std::ostringstream& strStreamMessage, bool bSaveInLog ) :
strMessage_( strStreamMessage.str() ) {
if ( bSaveInLog ) {
Logger::log( strMessage_, Logger::TYPE_ERROR );
}
}
const std::string& ExceptionHandler::getMessage() const {
return strMessage_;
}
} // namespace demo
Logger:
Logger.h
#ifndef LOGGER_H
#define LOGGER_H
#include "Singleton.h"
namespace demo {
class Logger final : public Singleton {
public:
enum LoggerType {
TYPE_INFO = 0,
TYPE_WARNING,
TYPE_ERROR,
TYPE_CONSOLE,
}; // LoggerType
private:
std::string strLogFilename_;
unsigned uMaxCharacterLength_;
std::array<std::string, 4> aLogTypes_;
const std::string strUnknownLogType_;
HANDLE hConsoleOutput_;
WORD consoleDefaultColor_;
public:
explicit Logger( const std::string& strLogFilename );
virtual ~Logger();
static void log( const std::string& strText, LoggerType eLogType = TYPE_INFO );
static void log( const std::ostringstream& strStreamText, LoggerType eLogType = TYPE_INFO );
static void log( const char* szText, LoggerType eLogType = TYPE_INFO );
Logger( const Logger& c ) = delete;
Logger& operator=( const Logger& c ) = delete;
};
} // namespace demo
#endif // !LOGGER_H
Logger.cpp
#include "stdafx.h"
#include "Logger.h"
#include "BlockThread.h"
#include "TextFileWriter.h"
namespace demo {
static Logger* s_pLogger = nullptr;
static CRITICAL_SECTION s_criticalSection;
static const WORD WHITE_ON_RED = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY | BACKGROUND_RED; // White Text On Red Background
Logger::Logger( const std::string& strLogFilename ) :
Singleton( TYPE_LOGGER ),
strLogFilename_( strLogFilename ),
uMaxCharacterLength_( 0 ),
strUnknownLogType_( "UNKNOWN" ) {
// Oder must match types defined in Logger::Type enum
aLogTypes_[0] = "Info";
aLogTypes_[1] = "Warning";
aLogTypes_[2] = "Error";
aLogTypes_[3] = ""; // Console
// Find widest log type string
uMaxCharacterLength_ = strUnknownLogType_.size();
for each ( const std::string& strLogType in aLogTypes_ ) {
if ( uMaxCharacterLength_ < strLogType.size() ) {
uMaxCharacterLength_ = strLogType.size();
}
}
InitializeCriticalSection( &s_criticalSection );
BlockThread blockThread( s_criticalSection ); // Enter critical section
// Start log file
TextFileWriter file( strLogFilename_, false, false );
// Prepare console
hConsoleOutput_ = GetStdHandle( STD_OUTPUT_HANDLE );
CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
GetConsoleScreenBufferInfo( hConsoleOutput_, &consoleInfo );
consoleDefaultColor_ = consoleInfo.wAttributes;
s_pLogger = this;
logMemoryAllocation( true );
} // Logger()
Logger::~Logger() {
logMemoryAllocation( false );
s_pLogger = nullptr;
DeleteCriticalSection( &s_criticalSection );
} // ~Logger
void Logger::log( const std::string& strText, LoggerType eLogType ) {
log( strText.c_str(), eLogType );
}
void Logger::log( const std::ostringstream& strStreamText, LoggerType eLogType ) {
log( strStreamText.str().c_str(), eLogType );
}
void Logger::log( const char* szText, LoggerType eLogType ) {
if ( nullptr == s_pLogger ) {
std::cout << "Logger has not been initialized, can not log " << szText << std::endl;
return;
}
BlockThread blockThread( s_criticalSection ); // Enter critical section
std::ostringstream strStream;
// Default White Text On Red Background
WORD textColor = WHITE_ON_RED;
// Choose log type text string, display "UNKNOWN" if eLogType is out of range
strStream << std::setfill( ' ' ) << std::setw( s_pLogger->uMaxCharacterLength_ );
try {
if ( TYPE_CONSOLE != eLogType ) {
strStream << s_pLogger->aLogTypes_.at( eLogType );
}
if ( TYPE_WARNING == eLogType ) {
// Yellow
textColor = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN;
} else if ( TYPE_INFO == eLogType ) {
// Green
textColor = FOREGROUND_GREEN;
} else if ( TYPE_CONSOLE == eLogType ) {
// Cyan
textColor = FOREGROUND_GREEN | FOREGROUND_BLUE;
}
} catch ( ... ) {
strStream << s_pLogger->strUnknownLogType_;
}
// Date & Time
if ( TYPE_CONSOLE != eLogType ) {
SYSTEMTIME time;
GetLocalTime( &time );
strStream << " [" << time.wYear << "."
<< std::setfill( '0' ) << std::setw( 2 ) << time.wMonth << "."
<< std::setfill( '0' ) << std::setw( 2 ) << time.wDay << " "
<< std::setfill( ' ' ) << std::setw( 2 ) << time.wHour << ":"
<< std::setfill( '0' ) << std::setw( 2 ) << time.wMinute << ":"
<< std::setfill( '0' ) << std::setw( 2 ) << time.wSecond << "."
<< std::setfill( '0' ) << std::setw( 3 ) << time.wMilliseconds << "] ";
}
strStream << szText << std::endl;
// Log message
SetConsoleTextAttribute( s_pLogger->hConsoleOutput_, textColor );
std::cout << strStream.str();
// Save same message to file
try {
TextFileWriter file( s_pLogger->strLogFilename_, true, false );
file.write( strStream.str() );
} catch ( ... ) {
// Ignore, not saved in log file
std::cout << __FUNCTION__ << " failed to write to file: " << strStream.str() << std::endl;
}
// Reset to default color
SetConsoleTextAttribute( s_pLogger->hConsoleOutput_, s_pLogger->consoleDefaultColor_ );
}
} // namespace demo
Singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H
namespace demo {
class Singleton {
public:
// Number of items in enum type must match the number of items and order of items stored in s_aSingletons
enum SingletonType {
TYPE_LOGGER = 0, // MUST BE FIRST!
}; // enum SingleType
private:
SingletonType eType_;
public:
Singleton( const Singleton& c ) = delete;
Singleton& operator=( const Singleton& c ) = delete;
virtual ~Singleton();
protected:
explicit Singleton( SingletonType eType );
void logMemoryAllocation( bool isAllocated ) const;
};
} // namespace demo
#endif // !SINGLETON_H
Singleton.cpp
#include "stdafx.h"
#include "Singleton.h"
#include "Logger.h"
namespace demo {
struct SingletonInfo {
const std::string strSingletonName;
bool isConstructed;
SingletonInfo( const std::string& strSingletonNameIn ) :
strSingletonName( strSingletonNameIn ),
isConstructed( false )
{}
};
// Order must match types defined in Singleton::SingletonType enum
static std::array<SingletonInfo, 1> s_aSingletons = { SingletonInfo( "Logger" ) };
Singleton::Singleton( SingletonType eType ) :
eType_( eType ) {
bool bSaveInLog = s_aSingletons.at( TYPE_LOGGER ).isConstructed;
try {
if ( !s_aSingletons.at( eType ).isConstructed ) {
// Test Initialize Order
for ( int i = 0; i < eType; ++i ) {
if ( !s_aSingletons.at( i ).isConstructed ) {
throw ExceptionHandler( s_aSingletons.at( i ).strSingletonName +
" must be constructed before constructing " +
s_aSingletons.at( eType ).strSingletonName,
bSaveInLog );
}
}
s_aSingletons.at( eType ).isConstructed = true;
} else {
throw ExceptionHandler( s_aSingletons.at( eType ).strSingletonName +
" can only be constructed once.",
bSaveInLog );
}
} catch ( std::exception& ) {
// eType is out of range
std::ostringstream strStream;
strStream << __FUNCTION__ << " Invalid Singleton Type specified: " << eType;
throw ExceptionHandler( strStream, bSaveInLog );
}
}
Singleton::~Singleton() {
s_aSingletons.at( eType_ ).isConstructed = false;
}
void Singleton::logMemoryAllocation( bool isAllocated ) const {
if ( isAllocated ) {
Logger::log( "Created " + s_aSingletons.at( eType_ ).strSingletonName );
} else {
Logger::log( "Destroyed " + s_aSingletons.at( eType_ ).strSingletonName );
}
}
} // namespace demo
For the reset of the project code see the 2nd provided answer: If you are looking to up-vote or accept please use this as the primary answer to vote upon, and please do not vote on the 2nd answer as it is only reference to this answer!
Part 2: - Nested Function Stack Calls With Exceptions.
Note: - Please do not VOTE on this answer please refer to the first answer as this is just a continuation for reference of pertaining classes!
You can find Part 1 here. I had to split this into 2 separate answers for I was about 2,000 characters above the max character limit of 30,000. I do apologize for any inconvenience. However one can not apply this ExceptionHandler without the provided classes.
FileHandlers:
FileHandler.h
#ifndef FILE_HANDLER_H
#define FILE_HANDLER_H
namespace demo {
class FileHandler {
protected:
std::fstream fileStream_;
std::string strFilePath_;
std::string strFilenameWithPath_;
private:
bool bSaveExceptionInLog_;
public:
virtual ~FileHandler();
FileHandler( const FileHandler& c ) = delete;
FileHandler& operator=( const FileHandler& c ) = delete;
protected:
FileHandler( const std::string& strFilename, bool bSaveExceptionInLog );
void throwError( const std::string& strMessage ) const;
void throwError( const std::ostringstream& strStreamMessage ) const;
bool getString( std::string& str, bool appendPath );
};
} // namespace demo
#endif // !FILE_HANDLER_H
FileHandler.cpp
#include "stdafx.h"
#include "FileHandler.h"
namespace demo {
FileHandler::FileHandler( const std::string& strFilename, bool bSaveExceptionInLog ) :
bSaveExceptionInLog_( bSaveExceptionInLog ),
strFilenameWithPath_( strFilename ) {
// Extract path info if it exists
std::string::size_type lastIndex = strFilename.find_last_of( "/\\" );
if ( lastIndex != std::string::npos ) {
strFilePath_ = strFilename.substr( 0, lastIndex );
}
if ( strFilename.empty() ) {
throw ExceptionHandler( __FUNCTION__ + std::string( " missing filename", bSaveExceptionInLog_ ) );
}
}
FileHandler::~FileHandler() {
if ( fileStream_.is_open() ) {
fileStream_.close();
}
}
void FileHandler::throwError( const std::string& strMessage ) const {
throw ExceptionHandler( "File [" + strFilenameWithPath_ + "] " + strMessage, bSaveExceptionInLog_ );
}
void FileHandler::throwError( const std::ostringstream& strStreamMessage ) const {
throwError( strStreamMessage.str() );
}
bool FileHandler::getString( std::string& str, bool appendPath ) {
fileStream_.read( &str[0], str.size() );
if ( fileStream_.fail() ) {
return false;
}
// Trim Right
str.erase( str.find_first_of( char( 0 ) ) );
if ( appendPath && !strFilePath_.empty() ) {
// Add path if one exists
str = strFilePath_ + "/" + str;
}
return true;
}
} // namespace demo
TextFileReader.h
#ifndef TEXT_FILE_READER_H
#define TEXT_FILE_READER_H
#include "FileHandler.h"
namespace demo {
class TextFileReader : public FileHandler {
public:
explicit TextFileReader( const std::string& strFilename );
virtual ~TextFileReader() = default;
std::string readAll() const;
bool readLine( std::string& strLine );
TextFileReader( const TextFileReader& c ) = delete;
TextFileReader& operator=( const TextFileReader& c ) = delete;
};
} // namespace demo
#endif // !TEXT_FILE_READER_H
TextFileReader.cpp
#include "stdafx.h"
#include "TextFileReader.h"
namespace demo {
TextFileReader::TextFileReader( const std::string& strFilename ) :
FileHandler( strFilename, true ) {
fileStream_.open( strFilenameWithPath_.c_str(), std::ios_base::in );
if ( !fileStream_.is_open() ) {
throwError( __FUNCTION__ + std::string( " can not open file for reading" ) );
}
}
std::string TextFileReader::readAll() const {
std::ostringstream strStream;
strStream << fileStream_.rdbuf();
return strStream.str();
}
bool TextFileReader::readLine( std::string& strLine ) {
if ( fileStream_.eof() ) {
return false;
}
std::getline( fileStream_, strLine );
return true;
}
} // namespace demo
TextFileWriter.h
#ifndef TEXT_FILE_WRITER_H
#define TEXT_FILE_WRITER_H
#include "FileHandler.h"
namespace demo {
class TextFileWriter : public FileHandler {
public:
explicit TextFileWriter( const std::string& strFilename, bool bAppendToFile, bool bSaveExceptionInLog = true );
virtual ~TextFileWriter() = default;
void write( const std::string& str );
TextFileWriter( const TextFileWriter& c ) = delete;
TextFileWriter& operator=( const TextFileWriter& c ) = delete;
};
} // namespace demo
#endif // !TEXT_FILE_WRITER_H
TextFileWriter.cpp
#include "stdafx.h"
#include "TextFileWriter.h"
namespace demo {
TextFileWriter::TextFileWriter( const std::string& strFilename, bool bAppendToFile, bool bSaveExceptionInLog ) :
FileHandler( strFilename, bSaveExceptionInLog ) {
fileStream_.open( strFilenameWithPath_.c_str(),
std::ios_base::out | (bAppendToFile ? std::ios_base::app : std::ios_base::trunc) );
if ( !fileStream_.is_open() ) {
throwError( __FUNCTION__ + std::string( " can not open file for writing" ) );
}
}
void TextFileWriter::write( const std::string& str ) {
fileStream_ << str;
}
} // namespace demo
Processes & Threads
BlockProcess.h
#ifndef BLOCK_PROCESS_H
#define BLOCK_PROCESS_H
namespace demo {
class BlockProcess final {
private:
HANDLE hMutex_;
public:
explicit BlockProcess( const std::string& strName );
~BlockProcess();
bool isBlocked() const;
BlockProcess( const BlockProcess& c ) = delete;
BlockProcess& operator=( const BlockProcess& c ) = delete;
};
} // namespace demo
#endif // !BLOCK_PROCESS_H
BlockProccess.cpp
#include "stdafx.h"
#include "BlockProcess.h"
namespace demo {
BlockProcess::BlockProcess( const std::string& strName ) {
hMutex_ = CreateMutex( nullptr, FALSE, strName.c_str() );
}
BlockProcess::~BlockProcess() {
CloseHandle( hMutex_ );
}
bool BlockProcess::isBlocked() const {
return (hMutex_ == nullptr || GetLastError() == ERROR_ALREADY_EXISTS);
}
} // namespace demo
BlockThread.h
#ifndef BLOCK_THREAD_H
#define BLOCK_THREAD_H
namespace demo {
class BlockThread final {
private:
CRITICAL_SECTION* pCriticalSection_;
public:
explicit BlockThread( CRITICAL_SECTION& criticalSection );
~BlockThread();
BlockThread( const BlockThread& c ) = delete;
BlockThread& operator=( const BlockThread& c ) = delete;
};
} // namespace demo
#endif // !BLOCK_THREAD_H
BlockThread.cpp
#include "stdafx.h"
#include "BlockThread.h"
namespace demo {
BlockThread::BlockThread( CRITICAL_SECTION& criticalSection ) {
pCriticalSection_ = &criticalSection;
EnterCriticalSection( pCriticalSection_ );
}
BlockThread::~BlockThread() {
LeaveCriticalSection( pCriticalSection_ );
}
} // namespace demo
Utilities:
Utility.h
#ifndef UTILITY_H
#define UTILITY_H
namespace demo {
class Utility {
public:
static void pressAnyKeyToQuit();
static std::string toUpper( const std::string& str );
static std::string toLower( const std::string& str );
static std::string trim( const std::string& str, const std::string elementsToTrim = " \t\n\r" );
static unsigned convertToUnsigned( const std::string& str );
static int convertToInt( const std::string& str );
static float convertToFloat( const std::string& str );
static std::vector<std::string> splitString( const std::string& strStringToSplit, const std::string& strDelimiter, const bool keepEmpty = true );
Utility( const Utility& c ) = delete;
Utility& operator=( const Utility& c ) = delete;
private:
Utility(); // Private - Not A Class Object
template<typename T>
static bool stringToValue( const std::string& str, T* pValue, unsigned uNumValues );
template<typename T>
static T getValue( const std::string& str, std::size_t& remainder );
};
#include "Utility.inl"
} // namespace demo
#endif // !UTILITY_H
Utility.inl
template<typename T>
static bool Utility::stringToValue( const std::string& str, T* pValue, unsigned uNumValues ) {
int numCommas = std::count( str.begin(), str.end(), ',' );
if ( numCommas != uNumValues - 1 ) {
return false;
}
std::size_t remainder;
pValue[0] = getValue<T>( str, remainder );
if ( uNumValues == 1 ) {
if ( str.size() != remainder ) {
return false;
}
} else {
std::size_t offset = remainder;
if ( str.at( offset ) != ',' ) {
return false;
}
unsigned uLastIdx = uNumValues - 1;
for ( unsigned u = 1; u < uNumValues; ++u ) {
pValue[u] = getValue<T>( str.substr( ++offset ), remainder );
offset += remainder;
if ( (u < uLastIdx && str.at( offset ) != ',') ||
(u == uLastIdx && offset != str.size()) ) {
return false;
}
}
}
return true;
}
Utility.cpp
#include "stdafx.h"
#include "Utility.h"
namespace demo {
void Utility::pressAnyKeyToQuit() {
std::cout << "\nPress any key to quit." << std::endl;
_getch();
}
std::string Utility::toUpper( const std::string& str ) {
std::string result = str;
std::transform( str.begin(), str.end(), result.begin(), ::toupper );
return result;
}
std::string Utility::toLower( const std::string& str ) {
std::string result = str;
std::transform( str.begin(), str.end(), result.begin(), ::tolower );
return result;
}
std::string Utility::trim( const std::string& str, const std::string elementsToTrim ) {
std::basic_string<char>::size_type firstIndex = str.find_first_not_of( elementsToTrim );
if ( firstIndex == std::string::npos ) {
return std::string(); // Nothing Left
}
std::basic_string<char>::size_type lastIndex = str.find_last_not_of( elementsToTrim );
return str.substr( firstIndex, lastIndex - firstIndex + 1 );
}
template<>
float Utility::getValue( const std::string& str, std::size_t& remainder ) {
return std::stof( str, &remainder );
}
template<>
int Utility::getValue( const std::string& str, std::size_t& remainder ) {
return std::stoi( str, &remainder );
}
template<>
unsigned Utility::getValue( const std::string& str, std::size_t& remainder ) {
return std::stoul( str, &remainder );
}
unsigned Utility::convertToUnsigned( const std::string& str ) {
unsigned u = 0;
if ( !stringToValue( str, &u, 1 ) ) {
std::ostringstream strStream;
strStream << __FUNCTION__ << " Bad conversion of [" << str << "] to unsigned";
throw strStream.str();
}
return u;
}
int Utility::convertToInt( const std::string& str ) {
int i = 0;
if ( !stringToValue( str, &i, 1 ) ) {
std::ostringstream strStream;
strStream << __FUNCTION__ << " Bad conversion of [" << str << "] to int";
throw strStream.str();
}
return i;
}
float Utility::convertToFloat( const std::string& str ) {
float f = 0;
if ( !stringToValue( str, &f, 1 ) ) {
std::ostringstream strStream;
strStream << __FUNCTION__ << " Bad conversion of [" << str << "] to float";
throw strStream.str();
}
return f;
}
std::vector<std::string> Utility::splitString( const std::string& strStringToSplit, const std::string& strDelimiter, const bool keepEmpty ) {
std::vector<std::string> vResult;
if ( strDelimiter.empty() ) {
vResult.push_back( strStringToSplit );
return vResult;
}
std::string::const_iterator itSubStrStart = strStringToSplit.begin(), itSubStrEnd;
while ( true ) {
itSubStrEnd = search( itSubStrStart, strStringToSplit.end(), strDelimiter.begin(), strDelimiter.end() );
std::string strTemp( itSubStrStart, itSubStrEnd );
if ( keepEmpty || !strTemp.empty() ) {
vResult.push_back( strTemp );
}
if ( itSubStrEnd == strStringToSplit.end() ) {
break;
}
itSubStrStart = itSubStrEnd + strDelimiter.size();
}
return vResult;
}
} // namespace demo
Precompiled Headers:
stdafx.h
#ifndef STDAFX_H
#define STDAFX_H
// Included files that typically will not change
// during the development process of this application.
// System - Architect Includes
#include <Windows.h>
#include <process.h>
//#include <mmsystem.h>
// Character & Basic IO
#include <conio.h> // for _getch()
#include <tchar.h>
//---------------------------------------------//
// Standard Library Includes
// Atomics, Regular Expressions, Localizations
#include <atomic> // C++11
#include <clocale>
//#include <codecvt> // C++11 // Deprecated in C++17
#include <locale>
#include <regex>
// Numerics & Numeric Limits
#include <climits>
#include <cfloat>
#include <cstdint> // C++11
#include <cinttypes> // C++11
#include <limits>
#include <cmath>
#include <complex>
#include <valarray>
#include <random> // C++11
#include <numeric>
#include <ratio> // C++11
#include <cfenv> // C++11
// Strings, Streams & IO
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <fstream>
// Thread Support
#include <thread> // C++11
#include <mutex> // C++11
#include <shared_mutex> // C++14
#include <future> // C++11
#include <condition_variable> // C++11
// Containers
#include <array> // C++11
#include <stack>
#include <list>
#include <forward_list> // C++11
#include <map>
#include <unordered_map> // C++11
#include <queue>
#include <deque>
#include <set>
#include <unordered_set> // C++11
#include <vector>
// Algorithms, Iterators
#include <algorithm> // Note* C++ 17 also has <execution>
#include <iterator>
// Dynamic Memory
#include <new>
#include <memory>
#include <scoped_allocator> // C++11
// Utilities
#include <bitset>
#include <ctime> // Compatability with C style time formarts
#include <chrono> // C++ 11 - C++ Time Utilities
#include <functional>
#include <initializer_list> // C++11
#include <memory>
#include <thread>
#include <typeinfo>
#include <typeindex> // C++11
#include <type_traits> // C++11
#include <tuple> // C++11
#include <utility>
// C++ 17
#include <any>
#include <filesystem>
#include <optional>
#include <string_view>
#include <variant>
// C++ 20
// #include <compare>
// #include <charconv>
// #include <syncstream>
// 3rd Party Library Includes Here.
// User-Application Specific commonly used non changing headers.
#include "ExceptionHandler.h"
namespace demo {
enum ReturnCode {
RETURN_OK = 0,
RETURN_ERROR = 1,
}; // ReturnCode
extern const unsigned INVALID_UNSIGNED;
extern const unsigned INVALID_UNSIGNED_SHORT;
} // namespace demo
#endif // !STDAFX_H
stdafx.cpp
#include "stdafx.h"
namespace demo {
const unsigned INVALID_UNSIGNED = static_cast<const unsigned>(-1);
const unsigned INVALID_UNSIGNED_SHORT = static_cast<const unsigned short>(-1);
} // namespace demo
how can I write to a file at the nth line (for example the 5th line) in c++?
here's my attempt:
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
ifstream stream1("1.txt");
string line ;
ofstream stream2("2.txt");
int lineNumber = 0;
while(getline( stream1, line ) )
{
if (lineNumber == 5)
{
stream2 << "Input" << endl;
lineNumber = 0;
}
lineNumber++;
}
stream1.close();
stream2.close(); return 0;
}
in "1.txt", I have the word "Student" at the 4th line, now I want to ignore the above 4 lines and input the word "Input" at the 5th line (below the word "Student"). When I run the above code, the output file is blank. Any suggestion how to fix this? Thanks.
If I understand it right, all you want is a replica of 1.txt in 2.txt with just the specific line number replaced with your personal content.
In your case it seems, the word is "Input".
Well here is a code that I modified from your original one -
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
ifstream stream1("1.txt");
string line ;
ofstream stream2("2.txt");
int lineNumber = 0;
int line_to_replace = 4; //This will replace 5th line
while(getline( stream1, line ) )
{
if (lineNumber == line_to_replace)
{
stream2 << "Input" << endl;
}
else
stream2 << line << endl;
lineNumber++;
}
stream1.close();
stream2.close();
return 0;
}
Input File (1.txt) -
sdlfknas
sdfas
sdf
g
thtr
34t4
bfgndty
45y564
grtg
Output File (2.txt) -
sdlfknas
sdfas
sdf
g
Input
34t4
bfgndty
45y564
grtg
p.s. To learn and understand programming better, I would recommend not to use:
using namespace std;
When you're reading the 5th line, lineNumber equals 4 b/c you start your counting at 0.
Change if(lineNumber == 5)
to if(lineNumber == 4) You also have an issue where you're setting lineNumber = 0 then immediately incrementing to 1, so you're only going to count 4 lines before outputting again.
I would create a function like this...
bool isBlank(string line) {
if (!line.empty()) {
for (auto x: line) {
if (isalnum(x)) {
return false;
}
}
}
return true;
}
It returns true if a string is empty or has no alphanumeric characters.
You can call this function right after the getline statement.
The isalnum function is specified in <cctype>
After working with your code I managed to get the output that you desired. Here is the updated version of your code.
#include <iostream>
#include <fstream>
int main() {
std::ifstream stream1( "1.txt" );
std::string line;
std::ofstream stream2( "2.txt" );
int lineNumber = 1;
while ( getLine( stream1, line ) ) {
if ( lineNumber == 5 ) {
stream2 << "Input" << std::endl;
} else {
stream2 << std::endl;
lineNumber++;
}
}
stream1.close();
stream2.close();
return 0;
}
The one thing you have to make sure is that in your 1.txt that has the word student on the 4th line is that you must have at least 2 empty lines after this text in the file. A simple enter or carriage return will do! If you do not the while( getline() ) will go out of scope and it will not read the next line and the code block will never enter your if() statement when lineNumber == 5 and it will not print the text "Input" to your stream2 file stream object.
If your last line of text in your 1.txt file is the line with the string of text Student what happens here is it will add this line of text to your line string variable then the code will increment your lineNumber to equal 5. The next time you go into the while loop to call getline() it returns false because you are at the EOF since there are no more lines of text from the file to read in and this causes the while loop to break out of execution and it goes out of scope and the if( lineNumber == 5 ) never gets called because it is nested within the while loop's scope.
My first answer addressed the issue with your problem and getting the output to your text file appropriately. However as I mentioned about the while loop for reading in a line of text and using the same counter for both file streams is not very elegant. A more accurate way to do this which will also allow for debugging to be simplified would be to read in your full input file one line at a time and save each line into a string while storing your strings in a vector. This way you can parse each line of text that you need one at a time and you can easily traverse your vector to quickly find your line of text. You should also do checks to make sure your file exists and that it opens correctly.
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
int main() {
std::string strTextFileIn( "1.txt" );
std::ifstream in;
std::string strLine;
std::vector<std::string> vFileContents;
// Open File Stream
in.open( strTextFileIn.c_str(), std::ios_base::in );
// Test To Make Sure It Opened Properly And That It Exists
if ( !in.is_open() ) {
std::cout << "Failed to open file, check to make sure file exists." << std::endl;
return -1;
} else {
while ( !in.eof() ) {
// Get Line Of Text And Save To String
std::getline( in, strLine );
// Push String Into Vector
vFileContents.push_back( strLine );
}
}
// Done With File Close File Stream
if ( in.is_open() ) {
in.close();
}
// Now That We Have Read In The File Contents And Have Saved Each Line Of Text To A String
// And Stored It In Our Container (Vector) We Can Traverse Our Vector To Find Which String
// Matches The Text We Are Looking For Retrive Its Indexed Value And Then Write To Our
// Output File According To Where You Want The Text To Be Written
unsigned index = 0;
const std::string strLookup( "Student" );
for ( unsigned int i = 0; i < vFileContents.size(); i++ ) {
if ( vFileContents[i] == strLookup ) {
// Strings Match We Have Our Indexed Value
index = i;
}
}
// We Want To Write Our Line Of Text 1 Line Past Our Index Value As You Have Stated.
std::string strTextFileOut( "2.txt" );
std::ofstream out;
// Open Our File For Writting
out.open( strTextFileOut.c_str(), std::ios_base::out );
if ( !out.is_open() ) {
std::cout << "Failed To open file.";
vFileContents.clear();
return -1;
} else {
for ( unsigned int i = 1; i <= index; i++ ) {
out << std::endl; // Write Blank Lines
}
// The Text Or String You Want To Write To File
out << "Input" << std::endl;
}
// Done With File Stream
if ( in.is_open() ) {
in.close();
}
// Clear Out Vector
vFileContents.clear();
return 0;
} // main
Now this can be simplified a bit more by creating a class hierarchy for working with various file stream object types so that you don't have to write this code to open, close, check validity, read in full file or by line over and over again everywhere you need it. This makes it modular. However this structure relies on a few other classes such as an ExceptionHandler class and a Logger class. Below is a small multi file application.
stdafx.h NOTE: Not all of these includes and defines will be used here, but this is coming from a larger project of mine and I'm stripping out only the classes that are needed here, but leaving my standard header as is. The only contents that I stripped out of this "stdafx.h" is anything that has to deal with OpenGL, OpenAL, Ogg - Vorbis, GLM Libraries & APIs
#ifndef STDAFX_H
#define STDAFX_H
#define VC_EXTRALEAN // Exclude Rarely Used Stuff Windows Headers - Windows Only
// Instead of Creating Another File That VS Makes For You "targetver.h"
// I Will Just Append Its Contents Here
#include <SDKDDKVer.h> // Windows Only
#include <Windows.h> // Windows Only
#include <process.h>
#include <tchar.h>
#include <conio.h>
#include <memory>
#include <string>
#include <numeric>
#include <vector>
#include <array>
#include <unordered_map>
#include <queue>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <fstream>
#include "ExceptionHandler.h"
namespace pro {
enum ReturnCode {
RETURN_OK = 0,
RETURN_ERROR = 1,
};
extern const unsigned INVALID_UNSIGNED;
extern const unsigned INVALID_UNSIGNED_SHORT;
} // namespace pro
#endif // STDAFX_H
stdafx.cpp
#include "stdafx.h"
namespace pro {
const unsigned INVALID_UNSIGNED = static_cast<const unsigned>( -1 );
const unsigned INVALID_UNSIGNED_SHORT = static_cast<const unsigned short>( -1 );
} // namespace pro
ExceptionHandler.h
#ifndef EXCEPTION_HANDLER_H
#define EXCEPTION_HANDLER_H
namespace pro {
class ExceptionHandler sealed {
private:
std::string m_strMessage;
public:
explicit ExceptionHandler( const std::string& strMessage, bool bSaveInLog = true );
explicit ExceptionHandler( const std::ostringstream& strStreamMessage, bool bSavedInLog = true );
// ~ExceptionHandler(); // Default Okay
// ExeptionHandler( const ExceptionHandler& c ); // Default Copy Constructor Okay & Is Needed
const std::string& getMessage() const;
private:
ExceptionHandler& operator=( const ExceptionHandler& c ); // Not Implemented
}; // ExceptionHandler
} // namespace pro
#endif // EXCEPTION_HANDLER_H
ExceptionHandler.cpp
#include "stdafx.h"
#include "ExceptionHandler.h"
#include "Logger.h"
namespace pro {
ExceptionHandler::ExceptionHandler( const std::string& strMessage, bool bSaveInLog ) :
m_strMessage( strMessage ) {
if ( bSavedInLog ) {
Logger::log( m_strMessage, Logger::TYPE_ERROR );
}
}
ExceptionHandler::ExceptionHandler( const std::ostringstream& strStreamMessage, bool bSaveInLog ) :
m_strMessage( strStreamMessage.str() ) {
if ( bSaveInLog ) {
Logger::log( m_strMessage, Logger::TYPE_ERROR );
}
}
const std::string& ExceptionHandler::getMessage() const {
return m_strMessage;
}
} // namespace pro
BlockThread.h -- Needed For Logger
#ifndef BLOCK_THREAD_H
#define BLOCK_THREAD_H
namespace pro {
class BlockThread sealed {
private:
CRITICAL_SECTION* m_pCriticalSection;
public:
explicit BlockThread( CRITICAL_SECTION& criticalSection );
~BlockThread();
private:
BlockThread( const BlockThread& c ); // Not Implemented
BlockThread& operator=( const BlockThread& c ); // Not Implemented
}; // BlockThread
} // namespace pro
#endif // BLOCK_THREAD_H
BlockThread.cpp
#include "stdafx.h"
#include "BlockThread.h"
namespace pro {
BlockThread::BlockThread( CRTICAL_SECTION& criticalSection ) {
m_pCriticalSection = &criticalSection;
EnterCriticalSection( m_pCriticalSection );
}
BlockThread::~BlockThread() {
LeaveCriticalSection( m_pCriticalSection );
}
} // namespace pro
Logger is a Singleton since you will only want one instance of it while your application is running.
Singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H
namespace pro {
class Singleton {
public:
enum SingletonType {
TYPE_LOGGER = 0, // Must Be First!
// TYPE_SETTINGS,
// TYPE_ENGINE,
};
private:
SingletonType m_eType;
public:
virtual ~Singleton();
protected:
explicit Singleton( SingletonType eType );
void logMemoryAllocation( bool isAllocated ) const;
private:
Singleton( const Singleton& c ); // Not Implemented
Singleton& operator=( const Singleton& c ); // Not Implemented
}; // Singleton
} // namespace pro
#endif // SINGLETON_H
Singleton.cpp
#include "stdafx.h"
#include "Logger.h"
#include "Singleton.h"
//#include "Settings.h"
namespace pro {
struct SingletonInfo {
const std::string strSingletonName;
bool isConstructed;
SingletonInfo( const std::string& strSingletonNameIn ) :
strSingletonName( strSingletonNameIn ),
isConstructed( false ) {}
};
// Order Must Match Types Defined In Singleton::SingletonType enum
static std::array<SingletonInfo, 1> s_aSingletons = { SingletonInfo( "Logger" ) }; /*,
SingletonInfo( "Settings" ) };*/ // Make Sure The Number Of Types Matches The Number In This Array
Singleton::Singleton( SingletonType eType ) :
m_eType( eType ) {
bool bSaveInLog = s_aSingletons.at( TYPE_LOGGER ).isConstructed;
try {
if ( !s_aSingletons.at( eType ).isConstructed ) {
// Test Initialization Order
for ( int i = 0; i < eType; ++i ) {
if ( !s_aSingletons.at( i ).isConstructed ) {
throw ExceptionHandler( s_aSingletons.at( i ).strSingletonName + " must be constructed before constructing " + s_aSingletons.at( eType ).strSingletonName, bSaveInLog );
}
}
s_aSingletons.at( eType ).isConstructed = true;
/*if ( s_aSingletons.at( TYPE_ENGINE ).isConstructed &&
Setttings::get()->isDebugLogginEnabled( Settings::DEBUG_MEMORY ) ) {
logMemoryAllocation( true );
}*/
} else {
throw ExceptionHandler( s_aSingletons.at( eType ).strSingletonName + " can only be constructed once.", bSaveInLog );
}
} catch ( std::exception& ) {
// eType Is Out Of Range
std::ostringstream strStream;
strStream << __FUNCTION__ << " Invalid Singleton Type Specified: " << eType;
throw ExceptionHandler( strStream, bSaveInLog );
}
}
Singleton::~Singleton() {
/*if ( s_aSingletons.at( TYPE_ENGINE ).isConstructed &&
Settings::get()->isDebugLoggingEnabled( Settings::DEBUG_MEMORY ) ) {
logMemoryAllocation( false );
}*/
s_aSingletons.at( m_eType ).isConstructed = false;
}
void Singleton::logMemoryAllocation( bool isAllocated ) const {
if ( isAllocated ) {
Logger::log( "Created " + s_aSingletons.at( m_eType ).strSingletonName );
} else {
Logger::log( "Destroyed " + s_aSingletons.at( m_eType ).strSingletonName );
}
}
} // namespace pro
Logger.h
#ifndef LOGGER_H
#define LOGGER_H
#include "Singleton.h"
namespace pro {
class Logger sealed : public Singleton {
public:
// Number Of Items In Enum Type Must Match The Number
// Of Items And Order Of Items Stored In s_aLogTypes
enum LoggerType {
TYPE_INFO = 0,
TYPE_WARNING,
TYPE_ERROR,
TYPE_CONSOLE,
}; // LoggerType
private:
std::string m_strLogFilename;
unsigned m_uMaxCharacterLength;
std::array<std::string, 4> m_aLogTypes
const std::string m_strUnknownLogType;
HANDLE m_hConsoleOutput;
WORD m_consoleDefualtColor;
public:
explicit Logger( const std::string& strLogFilename );
virtual ~Logger();
static void log( const std::string& strText, LoggerType eLogType = TYPE_INFO );
static void log( const std::ostringstream& strStreamText, LoggerType eLogType = TYPE_INFO );
static void log( const char* szText, LoggerType eLogType = TYPE_INFO );
private:
Logger( const Logger& c ); // Not Implemented
Logger& operator=( const Logger& c ); // Not Implemented
}; // Logger
} // namespace pro
#endif // LOGGER_H
Logger.cpp
#include "stdafx.h"
#include "Logger.h"
#include "BlockThread.h"
#include "TextFileWriter.h"
namespace pro {
static Logger* s_pLogger = nullptr;
static CRITICAL_SECTION = s_criticalSection;
// White Text On Red Background
static const WORD WHITE_ON_RED = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY | BACKGROUND_RED;
Logger::Logger( const std::string& strLogFilename ) :
Singleton( TYPE_LOGGER ),
m_strLogFilename( strLogFilename ),
m_uMaxCharacterLength( 0 ),
m_strUnknownLogType( "UNKNOWN" ) {
// Order Must Match Types Defined In Logger::Type enum
m_aLogTypes[0] = "Info";
m_aLogTypes[1] = "Warning";
m_aLogTypes[2] = "Error";
m_aLogTypes[3] = ""; // Console
// Find Widest Log Type String
m_uMaxCharacterLength = m_strUnknownLogType.size();
for each( const std::string& strLogType in m_aLogTypes ) {
if ( m_uMaxCharacterLength < strLogType.size() ) {
m_uMaxCharacterLength = strLogType.size();
}
}
InitializeCriticalSection( &s_criticalSection );
BlockThread blockThread( s_criticalSection ); // Enter Critical Section
// Start Log File
TextFileWriter file( m_strLogFilename, false, false );
// Prepare Console
m_hConsoleOutput = GetStdHandle( STD_OUTPUT_HANDLE );
CONSOLE_SCREEN_BUFFER consoleInfo;
GetConsoleScreenBufferInfo( m_hConsoleOutput, &consoleInfo );
m_consoleDefaultColor = consoleInfo.wAttributes;
s_pLogger = this;
logMemoryAllocation( true );
}
Logger::~Logger() {
logMemoryAllocation( false );
s_pLogger = nullptr;
DeleteCriticalSection( &s_criticalSection );
}
void Logger::log( const std::string& strtext, LoggerType eLogType ) {
log( strText.c_str(), eLogType );
}
void Logger::log( const std::string& strText, LoggerType eLogType ) {
log( strText.str().c_str(), eLogType );
}
void Logger::log( const char* szText, LoggerType eLogType ) {
if ( nullptr == s_pLogger ) {
std::cout << "Logger has not been initialized, can not log " << szText << std::endl;
return;
}
BlockThread blockThread( s_criticalSection ); // Enter Critical Section
std::ostringstream strStream;
// Default White Text On Red Background
WORD textColor = WHITE_ON_RED;
// Chose Log Type Text String, Display "UNKNOWN" If eLogType Is Out Of Range
strStream << std::setfill(' ') << std::setw( s_pLogger->m_uMaxCharacterLength );
try {
if ( TYPE_CONSOLE != eLogType ) {
strStream << s_pLogger->m_aLogTypes.at( eLogType );
}
if ( TYPE_WARNING == eLogType ) {
// Yellow
textColor = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN;
} else if ( TYPE_INFO == eLogType ) {
// Green
textColor = FOREGROUND_GREEN;
} else if ( TYPE_CONSOLE == eLogType ) {
// Cyan
textColor = FOREGROUND_GREEN | FOREGROUND_BLUE;
}
} catch( ... ) {
strStream << s_pLogger->m_strUnknownLogType;
}
// Date And Time
if ( TYPE_CONSOLE != eLogType ) {
SYSTEMTIME time;
GetLocalTime( &time );
strStream << " [" << time.wYear << "."
<< std::setfill('0') << std::setw( 2 ) << time.wMonth << "."
<< std::setfill('0') << std::setw( 2 ) << time.wDay << " "
<< std::setfill(' ') << std::setw( 2 ) << time.wHour << ":"
<< std::setfill('0') << std::setw( 2 ) << time.wMinute << ":"
<< std::setfill('0') << std::setw( 2 ) << time.wSecond << "."
<< std::setfill('0') << std::setw( 3 ) << time.wMilliseconds << "] ";
}
strStream << szText << std::endl;
// Log Message
SetConsoleTextAttribute( s_pLogger->m_hConsoleOutput, textColor );
std::cout << strStream.str();
// Save Message To Log File
try {
TextFileWriter file( s_pLogger->m_strLogFilename, true, false );
file.write( strStream.str() );
} catch( ... ) {
// Not Saved In Log File, Write Message To Console
std::cout << __FUNCTION__ << " failed to write to file: " << strStream.str() << std::endl;
}
// Reset To Default Color
SetConsoleTextAttribute( s_pLogger->m_hConsoleOutput, s_pLogger->m_consoleDefaultColor );
}
} // namespace pro
FileHandler.h - Base Class
#ifndef FILE_HANDLER_H
#define FILE_HANDLER_H
namespace pro {
// class AssetStorage; // Not Used Here
class FileHandler {
protected:
// static AssetStorage* m_pAssetStorage; // Not Used Here
std::fstream m_fileStream;
std::string m_strFilePath;
std::string m_strFilenameWithPath;
private:
bool m_bSaveExceptionInLog;
public:
virtual ~FileHandle();
protected:
FileHandler( const std::string& strFilename, bool bSaveExceptionInLog );
void throwError( const std::string& strMessage ) const;
void throwError( const std::ostringstream& strStreamMessage ) const;
bool getString( std::string& str, bool appendPath );
private:
FileHandler( const FileHandler& c ); // Not Implemented
FileHandler& operator=( const FileHandler& c ); // Not Implemented
}; // FileHandler
} // namespace pro
#endif // FILE_HANDLER_H
FileHandler.cpp
#include "stdafx.h"
#include "FileHandler.h"
// #include "AssetStorage.h" // Not Used Here
namespace pro {
// AssetStorage* FileHandler::m_pAssetStorage = nullptr; // Not Used Here
FileHandler::FileHandler( const std::string& strFilename, bool bSaveExceptionInLog ) :
m_bSaveExceptionInLog( bSaveExceptionInLog ),
m_strFilenameWithPath( strFilename ) {
/*if ( bSaveExceptionInLog && nullptr == m_pAssetStorage ) {
m_pAssetStorage = AssetStorage::get();
}*/ // Not Used Here
// Extract Path Info If It Exists
std::string::size_type lastIndex = strFilename.find_last_of( "/\\" );
if ( lastIndex != std::string::npos ) {
m_strFilePath = strFilename.substr( 0, lastIndex );
}
if ( strFilename.empty() ) {
throw ExceptionHandler( __FUNCTION__ + std::string( " missing filename", m_bSaveExceptionInLog );
}
}
FileHandler::~FileHandler() {
if ( m_fileStream.is_open() ) {
m_fileStream.close();
}
}
void FileHandler::throwError( const std::string& strMessage ) const {
throw ExceptionHandler( "File [" + m_strFilenameWithPath + "] " + strMessage, m_bSaveExceptionInLog );
}
void FileHandler::throwError( const std::ostringstream& strStreamMessage ) const {
throwError( strStreamMessage.str() );
}
bool FileHandler::getString( std::string& str, bool appendPath ) {
m_fileStream.read( &str[0], str.size() );
if ( m_fileStream.fail() ) {
return false;
}
// Trim Right
str.erase( str.find_first_of( char( 0 ) ) );
if ( appendPath && !m_strFilePath.empty() ) {
// Add Path If One Exists
str = m_strFilePath + "/" + str;
}
return true;
}
} // namespace pro
Now for the two inherited classes that you have been waiting for to handle File Streams. These Two are Strictly Text. Others within my project are TextureFiles, ModelObjectFiles, etc. I will be showing only the TextFileReader & TextFileWriter.
TextFileReader.h
#ifndef TEXT_FILE_READER_H
#define TEXT_FILE_READER_H
#include "FileHandler.h"
namespace pro {
class TextFileReader : public FileHandler {
private:
public:
explicit TextFileReader( const std::string& strFilename );
// virtual ~ TextFileReader(); // Default Okay
std::string readAll() const;
bool readLine( std::string& strLine );
private:
TextFileReader( const TextFileReader& c ); // Not Implemented
TextFileReader& operator=( const TextFileReader& c ); // Not Implemented
}; // TextFileReader
} // namespace pro
#endif // TEXT_FILE_READER_H
TextFileReader.cpp
#include "stdafx.h"
#include "TextFileReader.h"
namespace pro {
TextFileReader::TextFileReader( const std::string& strFilename ) :
FileHandler( strFilename, true ) {
m_fileStream.open( m_strFilenameWithPath.c_str(), std::ios_base::in );
if ( !m_fileStream.is_open() ) {
throwError( __FUNCTION__ + std::string( " can not open file for reading" ) );
}
std::string TextFileReader::readAll() const {
std::ostringstream strStream;
strStream << m_fileStream.rdbuf();
return strStream.str();
}
bool TextFileReader::readLine( std::string& strLine ) {
if ( m_fileStream.eof() ) {
return false;
}
std::getline( m_fileStream, strLine );
return true;
}
} // namespace pro
TextFileWriter.h
#ifndef TEXT_FILE_WRITER_H
#define TEXT_FILE_WRITER_H
#include "FileHandler.h"
namespace pro {
class TextFileWriter : public FileHandler {
private:
public:
TextFileWriter( const std::string& strFilename, bool bAppendToFile, bool bSaveExceptionInLog = true );
void write( const std::string& str );
private:
TextFileWriter( const TextFileWriter& c ); // Not Implemented
TextFileWriter& operator=( const TextFileWriter& c ); // Not Implemented
}; // TextFileWriter
} // namespace pro
#endif // TEXT_FILE_WRITER_H
TextFileWriter.cpp
#include "stdafx.h"
#include "TextFileWriter.h"
namespace pro {
TextFileWriter::TextFileWriter( const std::string& strFilename, bool bAppendToFile, bool bSaveExceptionInLog ) :
FileHandler( strFilename, bSaveExceptionInLog ) {
m_fileStream.open( m_strFilenameWithPath.c_str(),
std::ios_base::out | ( bAppendToFile ? std::ios_base::app : std::ios_base::trunc ) );
if ( !m_fileStream.is_open() ) {
throwError( __FUNCTION__ + std::string( " can not open file for writing" ) );
}
}
void TextFileWriter::write( const std::string& str ) {
m_fileStream << str;
}
} // namespace pro
Now to see a sample of this in action. If you look in the Logger class you will already see a use of the TextFileWriter.
main.cpp
#include "stdafx.h"
#include "Logger.h"
#include "TextFileReader.h"
#include "TextFileWriter.h"
int _tmain( int iNumArguments, _TCHAR* pArgumentText[] ) {
using namespace pro;
try {
// This Is Using The TextFileWriter & Console Output
// Logger::TYPE_INFO is by default!
Logger logger( "logger.txt" );
logger.log( "Some Info" );
logger.log( "Error!", Logger::TYPE_ERROR );
logger.log( "Warning!", Logger::TYPE_WARNING );
TextFileReader textReaderSingle( "logger.txt" );
TextFileReader textReaderAll( "logger.txt" );
std::string strTextSingle;
std::string strTextAll;
textReaderSingle.readLine( strTextSingle );
std::cout << "Read Single Line: << std::endl << strText << std::endl << std::endl;
strTextAll = textReaderAll.readAll();
std::cout << "Read All: " << std::endl << strTextAll << std::endl;
//Check The logger.txt that was generated in your projects folder!
std::cout << "Press any key to quit" << std::endl;
_getch();
} catch ( ExceptionHandler& e ) {
std::cout << "Exception Thrown: " << e.getMessage() << std::endl;
std::cout << "Press any key to quit" << std::endl;
_getch();
return RETURN_ERROR;
} catch( ... ) {
std::cout << __FUNCTION__ << " Caught Unknown Exception" << std::endl;
std::cout << "Press any key to quit" << std::endl;
_getch();
return RETURN_ERROR;
}
return RETURN_OK;
}
A majority of this work is accredited to Marek A. Krzeminski, MASc at www.MarekKnows.com. In essence all of these class objects are his; the only major difference is I used my own namespace pro as opposed to his. Both main functions are of my own work, the first stand alone and the second using his library code.
This is a project that has been in the works for a few years now and most of my advanced knowledge of the C++ language is due to following his video tutorials. This current project is a fairly large scale professional quality GameEngine using Shaders in OpenGL. All of this has been typed and debugged by hand while following along his tutorials.
As a major note; I had also hand typed a majority of this here as well, if this does not compile correctly it may be due to typographical errors. The source it self is a working application. What you see here is a very small percentage of his works! I am willing to accept the credit as to answer this person's question with the accumulation of this knowledge but I can not accept credit for this as being my own work in order to protect Marek and his copyright materials.
With this kind of setup it is quite easy to create your own file parsers and multiple file parsers for different types of files. As I stated above there are two other classes inherited from FileHandler that I did not show. If you would like to see more of this project, please vist www.MarekKnows.com and join the community.