写入文件时如何忽略行

Question

如何在c ++中的第n行（例如第5行）写入文件？ 这是我的尝试：

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

在“ 1.txt”中，我在第四行有单词“ Student”，现在我想忽略上面的四行，并在第五行输入单词“ Input”（在单词“ Student”下方）。 当我运行上面的代码时，输​​出文件为空白。 任何建议如何解决这个问题？ 谢谢。

Answer 1

如果我理解正确，那么您想要的只是2.txt中1.txt的副本，只是将特定的行号替换为您的个人内容。

在您的情况下，单词似乎是“输入”。

好吧，这是我从您的原始代码中修改的代码-

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

输入文件（1.txt）-

sdlfknas
sdfas
sdf
g
thtr
34t4
bfgndty
45y564
grtg

输出文件（2.txt）-

sdlfknas
sdfas
sdf
g
Input
34t4
bfgndty
45y564
grtg

ps为了更好地学习和理解编程，我建议不要使用：

using namespace std;

Answer 2

当您阅读第5行时， lineNumber等于4 b / c，您将从0开始计数。将if(lineNumber == 5)更改为if(lineNumber == 4)您还会遇到一个问题，即您要设置lineNumber = 0然后立即增加到1，因此您只需要计数4行，即可再次输出。

Answer 3

我会创建这样的功能...

bool isBlank(string line) { 
    if (!line.empty()) {
        for (auto x: line) {
            if (isalnum(x)) {
                return false;
            }
        }
    }
    return true;
}

如果字符串为空或没有字母数字字符，则返回true。

您可以在getline语句之后立即调用此函数。

isalnum函数在<cctype>指定

Answer 4

使用您的代码后，我设法获得了所需的输出。 这是您代码的更新版本。

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

您需要确保的一件事是，在1.txt文件的第四行带有单词Student的是，文件中此文本之后必须至少有2个空行。 一个简单的回车或回车就可以了！ 如果不这样做， while( getline() )将超出范围，并且不会读取下一行，并且当lineNumber == 5时，代码块将永远不会输入if()语句，并且不会打印文本"Input"到您的stream2文件流对象。

如果1.txt文件中的最后一行文本是包含文本字符串Student的行，这将发生此情况，它将文本行添加到line字符串变量中，然后代码会将lineNumber为等于5 。 下次进入while循环调用getline()它返回false，因为您在EOF因为文件中没有更多的文本行可供读取，这会导致while循环中断执行，并且超出范围，并且if( lineNumber == 5 )从未调用，因为它嵌套在while循环的范围内。

Answer 5

我的第一个答案解决了您遇到的问题，并将输出适当地输出到了文本文件中。 但是，正如我提到的while循环，用于读取一行文本并对两个文件流使用相同的计数器并不是很优雅。 一种更准确的方法（也可以简化调试）是一次在完整的输入文件中读取一行，并将每一行保存到字符串中，同时将字符串存储在向量中。 这样，您可以一次解析需要的每一行文本，并且可以轻松地遍历向量以快速找到文本行。 您还应该进行检查以确保文件存在并正确打开。

#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

现在，可以通过创建用于处理各种文件流对象类型的类层次结构来进一步简化该过程，从而无需编写此代码即可打开，关闭，检查有效性，读取完整文件或一遍又一遍地逐行再次在您需要的任何地方。 这使其成为模块化。 但是，此结构依赖于其他一些类，例如ExceptionHandler类和Logger类。 以下是一个小型的多文件应用程序。

stdafx.h注意：并非所有这些包含和定义都将在这里使用，但这是来自我的一个较大的项目，我仅去除此处所需的类，但保留了我的标准标头。 我从“ stdafx.h”中删除的唯一内容是必须处理OpenGL，Op​​enAL，Ogg-Vorbis，GLM库和API的所有内容

#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-记录器需要

#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是Singleton因为在您的应用程序运行时，您只需要它的一个实例。

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-基类

#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

现在，您已经在等待两个继承的类来处理文件流。 这两个是严格的文本。 我项目中的其他对象是TextureFiles，ModelObjectFiles等。我将仅显示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

现在来看一个实际的例子。 如果查看Logger类，您将已经看到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;
}

这项工作的大部分经过www.MarekKnows.com的认可，由MASc的Marek A. Krzeminski 负责 。 本质上，所有这些类对象都是他的； 唯一的主要区别是，我使用了自己的namespace pro而不是他。 这两个main功能都是我自己的工作，第一个独立使用，第二个使用他的库代码。

这是一个已经开展了几年的项目，我对C ++语言的大部分高级知识都来自于他的视频教程。 当前的项目是使用OpenGL中的着色器的相当大规模的专业质量GameEngine。 在遵循他的教程的过程中，所有这些都是手动键入和调试的。

作为主要说明； 我也曾在此处手动输入过大部分内容，如果无法正确编译，可能是由于印刷错误所致。 它本身的源代码是可以正常工作的应用程序。 您在这里看到的只是他作品的很小一部分！ 我愿意以积累的知识来回答这个人的问题，这一点我愿意接受，但是为了保护Marek及其版权材料，我不能接受这是我自己的工作。

通过这种设置，很容易为不同类型的文件创建自己的文件解析器和多个文件解析器。 如前所述，还有另外两个我没有显示的从FileHandler继承的类。 如果您想了解更多有关该项目的信息，请访问www.MarekKnows.com并加入社区。