Boost.String_Algo 的函数功能是相当的丰富了，也简便易用。所以可以在开发过程中大量使用。

BTW:有很多的人都排斥Boost，在一开始的时候我也不使用Boost，因为有太多的人建议我不要用。后来我还是使用了Boost，而且越用越喜欢，也越发感觉到Boost是一个多么灵活，高效，强大的C++ Library;也体会到了为什么可以称Boost具有”工业强度”。在这里，我建议那些不愿意使用Boost的朋友去使用一下Boost，也许你们是听别人建议不要用Boost，也许是自己不愿意使用Boost，但你们一定要去试用Boost中的一些可能用得上的Library，也许用了之后你们的看法会有所改变，也许你们会有不同的发现

本站原创文章，转载请注明出处。

#include <iostream>
#include <string>
#include <algorithm>
#include <iterator>
#include <set>

#include <stdlib.h>
#include <unistd.h>

#include <boost/foreach.hpp>
#include <boost/noncopyable.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/property_tree/ini_parser.hpp>

int main( int argc , char *argv[] )
{
    std::string strConfigName( "" );
    std::string strReportName( "" );

    const char *szShortOptions = ":f:t:h";
    while ( true )
    {
        const int iOption = getopt( argc , argv , szShortOptions );
        if ( -1 == iOption )
        {
            break;
        }

        switch ( iOption )
        {
        case 'f':
        {
            strConfigName = optarg;
        }
        break;

        case 't':
        {
            strReportName = optarg;
        }
        break;

        case ':':
        {
            std::cerr << "-" << static_cast< char >( iOption ) \
                      << " need option value." << std::endl;
        }
        break;

        case 'h':
        {
            std::cout << "usage: " << argv[ 0 ] << " -f config [-h]"
                      << std::endl;
            std::cout << "-f config     specify the config file name." \
                      << std::endl;
            std::cout << "-t report     specify the target report name." \
                      << std::endl;
            std::cout << "-h            show the help information." \
                      << std::endl;

        }
        return EXIT_SUCCESS;

        case '?':
        default:
        {
            std::cerr << "unknown option: " << static_cast< char >( iOption ) \
                      << std::endl;
        }
        break;

        }
    }

    if ( ( true == strConfigName.empty() ) \
            || ( true == strReportName.empty() ) )
    {
        std::cout << "ERROR, usage: " << argv[ 0 ] \
                  << " -f config" \
                  << "\t" \
                  << " -t report"
                  << std::endl;
        return -1;
    }

    /*

        typedef ::boost::property_tree::ptree IniParser;
        IniParser iniParser;

        const std::string strNullString = "";
        const int iDefaultIntValue = 0;

        read_ini( strConfigName , iniParser );
        const std::string strLogName = iniParser.get( "debug.log_name" , strNullString );
        const int iLogLevel = iniParser.get( "debug.level" , iDefaultIntValue );

        typedef std::set< std::string > ModuleSet;
        ModuleSet moduleSet;

        BOOST_FOREACH( IniParser::value_type &node , \
                iniParser.get_child( "modules" ) )
        {
                moduleSet.insert( node.second.data() );
        }

        std::string strIndex( "1" );

        IniParser reportINI;
        reportINI.put( "debug.log_name" , strLogName );
        reportINI.put( "debug.level" , iLogLevel);
        BOOST_FOREACH( const std::string &strName , moduleSet )
        {
                reportINI.put( "modules.module" + strIndex , \
                        strName );
                strIndex[ 0 ] += 1;
        }

        write_ini( strReportName , reportINI );
    */

    typedef ::boost::property_tree::ptree XmlParser;
    XmlParser xmlParser;

    const std::string strNullString = "";
    const int iDefaultIntValue = 0;

    read_xml( strConfigName , xmlParser );
    const std::string strLogName = xmlParser.get( "debug.log_name" , strNullString );
    const int iLogLevel = xmlParser.get( "debug.level" , iDefaultIntValue );

    typedef std::set< std::string > ModuleSet;
    ModuleSet moduleSet;

    BOOST_FOREACH( XmlParser::value_type &node , \
                   xmlParser.get_child( "debug.modules" ) )
    {
        moduleSet.insert( node.second.data() );
    }

    XmlParser reportXml;
    reportXml.put( "debug.log_name" , strLogName );
    reportXml.put( "debug.level" , iLogLevel);
    BOOST_FOREACH( const std::string &strName , moduleSet )
    {
        reportXml.put( "debug.modules.module" , \
                       strName );
    }

    write_xml( strReportName , reportXml );

    return EXIT_SUCCESS;

}

本站原创文章，转载请注明出处。

本站原创文章，转载请注明出处。

#include <iostream>
#include <string>

#include <boost/lexical_cast.hpp>

int main( int argc , char *argv[] )
{

    int iValue = 10;

    const std::string strValue = ::boost::lexical_cast< std::string >( iValue );
    std::cout << "strValue = " << strValue << std::endl;

    int iTarget = ::boost::lexical_cast< int >( strValue );
    std::cout << "iTarget = " << iTarget << std::endl;

    return 0;
}

本站原创文章，转载请注明出处。

C库中的sprintf/fprintf系统函数都针对一个指定长度的缓冲区进行操作，因此在不同的情况下设置缓冲区的长度以及缓冲区的长度而引起的缓冲区溢出问题会大大增加系统的安全隐患。

C++标准库中的stringstream相对于C库中的格式化函数是一个不错的选择，但是Boost.format相比于std::stringstream是一个更好的选择，因为其简单，高效且易用。
下面的例子用于说明 Boost.format的使用方法:

boost::format 使用方法
#include <boost/format.hpp>
#include <string>
#include <stdio.h>

int main( int argc , char *argv[] )
{
    using boost::format;
    boost::format formater( "%1% %2%" );;
    std::string strText = str( formater % 123 % "number" );
    fprintf( stdout , "%s\n" , strText.c_str() );

    strText = str( formater % 'c' % 3.14 );
    fprintf( stdout , "%s\n" , strText.c_str() );

    // 可以直接使用 "%N%" 来指定格式化的参数是传递的参数中的哪一个
    strText = str( boost::format( "%1% %1% %2% %2%" ) % 1 % 2 );
    fprintf( stdout , "%s\n" , strText.c_str() );

    // 也可以使用 "%s %d %f" 之类的printf格式的格式化字符指令来确定指定的参数被格式化的形式
    strText = str( boost::format( "%s , %d , %f" ) % "abc" % 123 % 456.7 );
    fprintf( stdout , "%s\n" , strText.c_str() );

    // 使用 "%N%" 比 "%flag" 的好处在于，前者可以在格式化时对传递进来的参数使用多次.

    formater % 9;

    // 清除之前传入的参数 "9"
    formater.clear();
    formater % 1234 % 5678;
    fprintf( stdout , "%s\n" , formater.str().c_str() );

    // 改变其中的某个传入的参数
    formater % 12 % 34;
    formater.bind_arg( 1 , 6666 );
    fprintf( stdout , "%s\n" , formater.str().c_str() );

    // 一旦格式化成功之后，如果调用任何的函数获取了其中的"格式化之后的字符串"，那么这个格式化的字符串将不能再进行参数的修改了，
    // 直到下一次调用 "%" 传入参数开始，之前被格式化的参数将会被清除，以新传入的参数进行新的格式化操作.

    return 0;
}

本站原创文章，转载请注明出处。