c++ Crash happened when built with -xipo -xO4 - c++

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.

Related

How to avoid using exceptions, as a form of control flow, to jump through through deeply nested function calls?

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 to ignore lines when writing to a file

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.

C++ callstack on windows access violation

I have been trying to make a Windows application dump the callstack on the event of a crash (bad memory access or division by zero) or standard c++ exceptions.
I have build StackWalker and linked it into my application and compiled my application with /EHa.
#include "win/StackWalker.h"
extern int runapp(int argc, char **argv);
// The exception filter function:
LONG WINAPI ExpFilter(EXCEPTION_POINTERS* pExp, DWORD dwExpCode) {
StackWalker sw;
sw.ShowCallstack(GetCurrentThread(), pExp->ContextRecord);
return EXCEPTION_EXECUTE_HANDLER;
}
int main(int argc, char *argv[]) {
__try
{
return runapp(argc, argv);
}
__except (ExpFilter(GetExceptionInformation(), GetExceptionCode()))
{
}
}
The real program is started via runapp() since it is not possible to instantiate objects that require unwinding (destruction) directly inside a __try scope.
My problem is that nothing is caught when I force my program to crash using this code:
int *data1 = 0;
*data1 = 0;
In other words, it just crashes "normally"
Does anybody have a hint?
/EHa switch tells compiler that you want to handle SEH exceptions inside C++ try/catch block. In your code you use SEH exception handler instead. This is a working approach I am using:
dbgutils.h
#pragma once
#include <eh.h>
#include <windows.h>
#include <string>
#include <sstream>
#include <iomanip>
#include <boost/optional.hpp>
#include "StackWalker.h"
class CSO3SEHException
{
public:
CSO3SEHException(unsigned int nCode, EXCEPTION_POINTERS* pEx);
std::string what();
std::string stack();
private:
std::string m_sWhat, m_sStack;
std::string seName(const unsigned int& nCode);
boost::optional<std::string> seInfo(unsigned int nCode, EXCEPTION_POINTERS* pEx);
void seStack(EXCEPTION_POINTERS* pEx);
void seExceptionInfo(unsigned int nCode, EXCEPTION_POINTERS* pEx);
};
class CCustomStackWalker : public StackWalker
{
public:
CCustomStackWalker(std::stringstream* ss);
protected:
virtual void OnOutput(LPCSTR szText);
private:
std::stringstream* m_sOut;
};
void _so3_seh_translate(unsigned int code, _EXCEPTION_POINTERS *ep);
void ReportSEHException(CSO3SEHException& ex);
dbgutils.cpp
#include "dbgutils.h"
CCustomStackWalker::CCustomStackWalker(std::stringstream* ss)
{
m_sOut = ss;
}
void CCustomStackWalker::OnOutput(LPCSTR szText)
{
size_t sLen = strlen(szText);
std::string s = std::string(szText, sLen);
(*m_sOut) << s << std::endl;
}
CSO3SEHException::CSO3SEHException(unsigned int nCode, EXCEPTION_POINTERS* pEx)
{
seExceptionInfo(nCode, pEx);
seStack(pEx);
}
std::string CSO3SEHException::what()
{
return(m_sWhat);
}
std::string CSO3SEHException::stack()
{
return(m_sStack);
}
std::string CSO3SEHException::seName(const unsigned int& nCode)
{
switch (nCode)
{
case EXCEPTION_ACCESS_VIOLATION: return ("Access Violation");
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: return ("Range Check");
case EXCEPTION_BREAKPOINT: return ("Breakpoint");
case EXCEPTION_DATATYPE_MISALIGNMENT: return ("Datatype misaligment");
case EXCEPTION_ILLEGAL_INSTRUCTION: return ("Illegal instruction");
case EXCEPTION_INT_DIVIDE_BY_ZERO: return ("Divide by zero");
case EXCEPTION_INT_OVERFLOW: return ("Integer overflow");
case EXCEPTION_PRIV_INSTRUCTION: return ("Privileged instruction");
case EXCEPTION_STACK_OVERFLOW: return ("Stack overflow");
default: return("UNKNOWN EXCEPTION");
}
}
boost::optional<std::string> CSO3SEHException::seInfo(unsigned int nCode, EXCEPTION_POINTERS* pEx)
{
std::stringstream ss;
if (EXCEPTION_ACCESS_VIOLATION == nCode)
{
ss << (pEx->ExceptionRecord->ExceptionInformation[0] ? "write " : " read");
ss << std::hex << std::setfill('0');
ss << " of address 0x" << std::setw(2*sizeof(void*)) << (unsigned)pEx->ExceptionRecord->ExceptionInformation[1];
return(ss.str());
}
return(nullptr);
}
void CSO3SEHException::seStack(EXCEPTION_POINTERS* pEx)
{
std::stringstream ss;
CCustomStackWalker sw(&ss);
sw.ShowCallstack(GetCurrentThread(), pEx->ContextRecord);
m_sStack = ss.str();
}
void CSO3SEHException::seExceptionInfo(unsigned int nCode, EXCEPTION_POINTERS* pEx)
{
std::stringstream ss;
ss << seName(nCode);
ss << std::hex << std::setfill('0');
ss << " at 0x" << std::setw(2*sizeof(void*)) << pEx->ExceptionRecord->ExceptionAddress;
auto pSInfo = seInfo(nCode, pEx);
if (pSInfo)
ss << *pSInfo;
m_sWhat = ss.str();
}
void _so3_seh_translate(unsigned int code, _EXCEPTION_POINTERS *ep)
{
throw CSO3SEHException(code, ep);
}
void ReportSEHException(CSO3SEHException& ex)
{
std::string sError = ex.what();
std::string sStack = ex.stack();
//do some error reporting here
}
somewhere in your code:
//You have to call _set_se_translator in all threads
_set_se_translator(_so3_seh_translate);
try
{
//do something exception-prone
}
catch (CSO3SEHException & pSEH)
{
ReportSEHException(pSEH);
}
catch (std::exception& err)
{
//handle c++ exceptions
}
The following solution works cross-platform (with the inclusion of StackWalker). Unfortunately it only works across threads on posix systems.
If someone has a solution for catching crashes/exceptions in all threads on Windows please tell.
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#ifdef WINDOWS_OS
#include <windows.h>
#include "StackWalker.h"
#include <DbgHelp.h>
#include <iostream>
void seg_handler(int sig)
{
unsigned int i;
void * stack[ 100 ];
unsigned short frames;
SYMBOL_INFO * symbol;
HANDLE process;
process = GetCurrentProcess();
SymInitialize( process, NULL, TRUE );
frames = CaptureStackBackTrace( 0, 100, stack, NULL );
symbol = ( SYMBOL_INFO * )calloc( sizeof( SYMBOL_INFO ) + 256 * sizeof( char ), 1 );
symbol->MaxNameLen = 255;
symbol->SizeOfStruct = sizeof( SYMBOL_INFO );
for( i = 0; i < frames; i++ ) {
SymFromAddr( process, ( DWORD64 )( stack[ i ] ), 0, symbol );
printf( "%i: %s - 0x%0X\n", frames - i - 1, symbol->Name, symbol->Address );
}
free( symbol );
StackWalker sw;
sw.ShowCallstack(GetCurrentThread());
exit(1);
}
void std_handler( void ) {
seg_handler(1);
}
#else
#include <execinfo.h>
#include <unistd.h>
void seg_handler(int sig) {
void *array[10];
size_t size;
// get void*'s for all entries on the stack
size = backtrace(array, 10);
// print out all the frames to stderr
fprintf(stderr, "Error: signal %d:\n", sig);
backtrace_symbols_fd(array, size, STDERR_FILENO);
exit(1);
}
void std_handler( void )
{
void *trace_elems[20];
int trace_elem_count(backtrace( trace_elems, 20 ));
char **stack_syms(backtrace_symbols( trace_elems, trace_elem_count ));
for ( int i = 0 ; i < trace_elem_count ; ++i )
{
std::cout << stack_syms[i] << "\n";
}
free( stack_syms );
exit(1);
}
#endif
int main(int argc, char *argv[]) {
signal(SIGSEGV, seg_handler);
std::set_terminate( std_handler );
// Main Program
// Crash
int *a = 0;
*a = 1;
}

C++ cannot catch the exception thrown from curlpp in Mac OS with g++-mp-4.4

I have following code (now compilable, thanks to #LokiAstari):
To compile the following piece of code, the simplest way is to download curlpp , compile it. Then compile the following code with g++-mp-4.4 (installed by macport), linking to curl and curlpp.
It would crash (output: abort trap) if localhost:8080 does not exist.
Change g++-mp-4.4 to g++ which the default one of Xcode 4, it works fine.
#include <string>
#include <sstream>
#include <iostream>
#include <curlpp/cURLpp.hpp>
#include <curlpp/Easy.hpp>
#include <curlpp/Options.hpp>
int main(int, char **)
{
try
{
curlpp::Cleanup myCleanup;
{
std::ostringstream os;
os << curlpp::options::Url("http://localhost:8080/");
}
}
catch( curlpp::RuntimeError &e )
{
std::cout << e.what() << std::endl;
}
catch( curlpp::LogicError &e )
{
std::cout << e.what() << std::endl;
}
return 0;
}
Update:
in Easy.cpp:
void
curlpp::Easy::perform()
{
mCurl->perform(); // The exception come from here. mCurl is a std::auto_ptr<internal::CurlHandle> mCurl;
}
......
std::ostream & operator<<(std::ostream & stream, const curlpp::Easy & request)
{
// Quick clone that doesn't copy options, only the curl handle.
curlpp::Easy r(request.getCurlHandle().clone());
r.setOpt(new curlpp::options::WriteStream(& stream));
r.perform(); // The exception come from here.
return stream;
}
in CurlHandle.cpp:
void CurlHandle::perform()
{
CURLcode code;
code = curl_easy_perform(mCurl);
throwException();
libcurlRuntimeAssert(mErrorBuffer, code); //if we got an error
}
in Exception.cpp:
void curlpp::libcurlRuntimeAssert(const std::string & reason, CURLcode code)
{
curlpp::libcurlRuntimeAssert(reason.c_str(), code);
}
void curlpp::libcurlRuntimeAssert(const char * reason, CURLcode code)
{
if (code != CURLE_OK)
throw curlpp::LibcurlRuntimeError(reason, code);
}
I traced into the code, throw curlpp::LibcurlRuntimeError(reason, code);, the constructor of LibcurlRuntimeError is fine, then throw, then SIGABRT.
stack trace:
0 __kill 0 0x7fff8213d0b6
1 abort 0 0x7fff821dd9f6
2 uw_init_context_1 0 0x101663af2
3 _Unwind_Resume 0 0x101663f38
4 operator<< Easy.cpp 118 0x10009b699
5 operator<< Options.cpp 34 0x1000948d8
6 RoleCreationTest::loadPlayerAsyncTestCase rolecreationtest.cpp 147 0x10008c714
7 RoleCreationTest::qt_metacall moc_rolecreationtest.cpp 87 0x1000acab2
8 QMetaMethod::invoke 0 0x1012e6667
There are problems with various MacPorts GCC 4.x compilers and exception catching, see for example GCC bug 42159 and MacPorts bug 25042.

android + pthread + c++ = SIGSEGV

The following code compiles and runs on standard linux:
#include <iostream>
#include <pthread.h>
using namespace std;
class Foo
{
public:
Foo();
void go_thread();
void stop_thread();
private:
static void* worker( void* param );
pthread_t m_pt;
};
Foo::Foo()
{
m_pt = 0;
}
void Foo::go_thread()
{
int success = pthread_create( &m_pt, NULL, worker, static_cast<void*>(this) );
if( success == 0 )
{
cout << "thread started" << endl;
}
}
void Foo::stop_thread()
{
int success = pthread_join( m_pt, NULL );
if( success == 0 )
{
cout << "thread stopped" << endl;
}
}
void* Foo::worker( void* p )
{
cout << "thread running" << endl;
return 0;
}
int main()
{
Foo f;
f.go_thread();
f.stop_thread();
return 0;
}
and produces the following output:
$ ./a.out
thread started
thread running
thread stopped
$
This code also builds with the Android NDK (r5b). However, when I adb push the resulting executable to a device and run it, I get a SIGSEGV before main() even runs. I've isolated the issue down to pthread_create() It seems the mere existence of this call in my code, never mind execution, causes my prog to seg fault. Any ideas?
It may not be this but try making the function called by pthread create a normal c-function (i.e. declare it as extern "C") not a static member function:
This is because technically the calling convention for static members may be different from the C calling convention that is used by the C-library pthread (though a lot of the times they are the same (which is why it works on your linux box) in my opinion it is not worth the porting risk).
extern "C" void* start_the_thread(void*);
void* start_the_thread(void* data)
{
Foo* theObject = static_cast<Foo*>(data);
// In Java if your Foo had been derived from Runable
// This is s where theObject->run() would have been called.
return Foo::worker(data);
}
int success = pthread_create( &m_pt, NULL, start_the_thread, static_cast<void*>(this)
The issue seems to be combining iostream with pthread. I went through and replaced all couts with printf()s, removed the using clause, and removed the iostream header. The code compiled and ran with no issue on the device. I wonder if this is something Google should be made aware of?
The final (working) code looks like:
#include <pthread.h>
#include <stdio.h>
class Foo
{
public:
Foo();
void go_thread();
void stop_thread();
private:
static void* worker( void* param );
pthread_t m_pt;
};
Foo::Foo()
{
m_pt = 0;
}
void Foo::go_thread()
{
int success = pthread_create( &m_pt, NULL, worker, static_cast<void*>(this) );
if( success == 0 )
{
printf( "thread started\n" );
}
}
void Foo::stop_thread()
{
int success = pthread_join( m_pt, NULL );
if( success == 0 )
{
printf( "thread stopped\n" );
}
}
void* Foo::worker( void* p )
{
printf( "thread running\n" );
return 0;
}
int main()
{
Foo f;
f.go_thread();
f.stop_thread();
return 0;
}