亚洲高清免费在线,欧美在线free,在线精品视频一区二区

lf426 — Sat, 26 Jun 2010 11:55:00 GMT

<本文PDF文档下蝲>

��编码的��伤

我们现在知道�Q�C/C++的宽�H��{换是依赖�pȝ��的locale的，�q�且在运行时完成。考虑�q�样一�U�情况，我们在简体中文Windows下编译如下语句：
const char* s = "中文abc";
�Ҏ(gu��)��我们之前的讨论，�~�译器将按照Windows Codepage936�Q�GB2312�Q�对�q�个字符串进行编码。如果我们在�E�序中运行宽�H��{换函敎ͼ��s转换为宽字符串ws�Q�如果这个程序运行在��体中文环境下是没问题的，��执行从GB2312到UCS-2BE的�{换；但是�Q�如果在其他语言环境下，比如是繁体中文BIG5�Q�程序将�Ҏ(gu��)��pȝ��的locale执行从BIG5到UCS-2BE的�{换，�q�显然就出现了错误�?br>
补救

有没有补救这个问题的办法呢？一个解��x��案就是执行不依赖locale的宽�H��{换。实际上�Q�这��已�l�不是宽�H��{换之间的问题了，而是�~�码之间转换的问题了。我们可以用GNU的libiconv实现��L��~�码间的转换�Q�对于以上的具体情况�Q�指明是从GB2312到UCS-2BE��׃��会出错。（请参考本人前面的章节�Q?a title=win32下的libiconv href="http://www.shnenglu.com/lf426/archive/2008/03/30/45738.html">win32下的libiconv�Q�，但这昄��是一个笨拙的�{�略�Q�我们在��体中文Windows下必��M��用GB2312到UCS-2BE版本的宽�H��{换函敎ͼ��C��BIG5环境下，��必��重新写从BIG5到UCS-2BE的宽�H��{换函数�?br>
Windows的策�?br>
Windows的策略是淘汰了窄字符�Ԍ��q�脆只用宽字�W�串。所有的��编码全部加上特定宏�Q�比如TEXT()�Q�如果程序是所谓Unicode�~�译�Q�在�~�译时就��译为UCS2-BE——Windows自称为Unicode�~�程�Q�其本质是��用了UCS-2BE�?6位宽字符丌Ӏ?br>
Linux的策�?br>
Linux下根本就不存在这个问题！因�ؓ各种语言的Linux都��用UTF-8的编码，所以，无论�pȝ��locale如何变化�Q�窄到宽转换的规则一直是UTF-8到UTF32-BE �?br>
跨��^台策�?br>
因�ؓ�?6位的范围内，UTF32-BE的前16位�ؓ0�Q�后16位与UCS2-BE是一��L��Q�所以，即��wchar_t的sizeof()不一��P��在一般情况下�Q�跨�q�_��使用宽字�W�（�Ԍ��也应该是兼容的。但是依然存在潜在的问题�Q�就是那�?字节的UTF32�~�码�?br>
gettext�{�略

以上都是��ASCII及以外的�~�码��编码在�E�序中的办法。GNU的gettext提供了另外一�U�选择�Q�在�E�序中只��编码ASCII�Q�多语言支持由gettext函数库在�q�行时加载。（对gettext的介�l�请参考本人前面的章节�Q?a title=Win32下的GetText href="http://www.shnenglu.com/lf426/archive/2008/03/30/45723.html">Win32下的GetText�Q�。gettext的多语言��译文�g不在�E�序中，而是单独的提出来攑֜�特定的位�|�。gettext明确的知道这些翻译文件的�~�码�Q�所以可以准��的告诉�l�系�l�翻译的正确信息�Q�而系�l�将�q�些信息以当前的�pȝ��locale�~�码成窄字符串反馈给�E�序。例如，在简体中文Windows中，gettext的po文�g也可以以UTF-8储存�Q�gettext��po文�g��译成mo文�g�Q�确保mo文�g在�Q何系�l�和语言环境下都能够正确��译。在�q�行是传�l�win32�E�序的窄串符合当前locale�Q�是GB2312。gettext让国际化的翻译更加的方便�Q�缺�Ҏ(gu��)��目前我没扑ֈ�支持宽字�W�串的版本（据说是有ugettext()支持宽字�W�串�Q�，所以要使用gettext只能使用�H�字�W�串。但是gettext可以转换到宽字符�Ԍ��而且不会出现宽窄转换的问题，因�ؓgettext是运行时�Ҏ(gu��)��locale��译的。例如：
const char* s = gettext("Chinese a b c");
其中"Chinese a b c"在po中的��译�?中文abc"
使用依赖locale的运行时宽窄转换函数�Q?br>const std::wstring wstr = s2ws(s);
�q�行时调用该po文�g对应的mo文�g�Q�在��体中文环境下��׃��GB2312传给�E�序�Q�在�J�体中文中就以BIG5传给�E�序�Q�这样s2ws()总能够正常换��编码�?br>
更多

在本文的最后，我想回到C++的stream问题上。用fstream转换如此的简单，sstream却不支持。改造一个支持codecvt的string stream需要改造basic_stringbuf。basic_stringbuf和basic_filebuf都派生自basic_streambuf�Q�所不同的是basic_filebuf在构造和open()的时候调用了codecvt�Q�只需要在basic_stringbuf中添加这个功能就可以了。说��h��Ҏ(gu��)��Q�实际上是需要重新改造一个STL模板�Q�尽��这些模板源代码都是在标准库头文件中现成的，但是我还是水�q�x��限，没有��L��I�了。另外一个思�\是构��Z��个基于内存映��的虚拟文�g�Q�这个框架在boost的iostreams库中�Q�有兴趣的朋友可以深入的研究�?br>�Q�完�Q?

lf426 2010-06-26 19:55 发表评论

��d��解密C++宽字�W�：5、利用fstream转换

lf426 — Sat, 26 Jun 2010 08:40:00 GMT

<本文PDF文档下蝲>

C++的流和本地化�{�略�?br>
BS在设计C++��的时候希望其具备��化，�q�且是可扩展的智能化�Q�也��是��_��C++的流可以“��L��”一些内宏V��比如：

std::cout << 123 << "ok" << std::endl;

�q�句代码中，std::cout是能判断�?23是int�?ok"是const char[3]。利用流的智能，甚至可以做一些基��c�d��的�{换，比如从int到string�Q�string到int�Q?br>

std::string str("123");
std::stringstream sstr(str);
int i;
sstr >> i;

int i = 123;
std::stringstream sstr;
sstr << i;
std::string str = sstr.str();

��管如此�Q�C++�q�不满��Q�C++甚至希望��能“明白”旉��Q�货币的表示法。而时间和货币的表�C�方法在世界范围内是不同的，所以，每一个流都有自己的locale在媄响其行�ؓ�Q�C++中叫做激�z�（imbue�Q�也有翻译成��染�Q�。而我们知道，每一个locale都有多个facet�Q�这些facet�q��L��被use_facet使用的。决定��用哪些facet的，是流的缓存basic_streambuf及其�z��c�basic_stringbuf和basic_filebuf。我们要用到的facet是codecvt�Q�这个facet只被basic_filebuf使用——这��是��Z��么只能用fstream来实现宽�H��{换，而无法��用sstream来实现的原因�?br>头文�Ӟ��

//filename string_wstring_fstream.hpp
#ifndef STRING_WSTRING_FSTREAM_HPP
#define STRING_WSTRING_FSTREAM_HPP

#include <string>

const std::wstring s2ws(const std::string& s);
const std::string ws2s(const std::wstring& s);

#endif

实现�Q?br>

#include <string>
#include <fstream>
#include "string_wstring_fstream.hpp"

const std::wstring s2ws(const std::string& s)
{
    std::locale sys_loc("");

    std::ofstream ofs("cvt_buf");
    ofs << s;
    ofs.close();

    std::wifstream wifs("cvt_buf");
    wifs.imbue(sys_loc);
    std::wstring wstr;
    wifs >> wstr;
    wifs.close();

    return wstr;
}

const std::string ws2s(const std::wstring& s)
{
    std::locale sys_loc("");

    std::wofstream wofs("cvt_buf");
    wofs.imbue(sys_loc);
    wofs << s;
    wofs.close();

    std::ifstream ifs("cvt_buf");
    std::string str;
    ifs >> str;
    ifs.close();

    return str;
}

在窄到宽的�{化中�Q�我们先使用默认的本地化�{�略集（locale�Q�将s通过�H�文件流ofs传入文�g�Q�这是char到char的传递，没有��M��转换�Q�然后我们打开宽文件流wifs�Q��ƈ用系�l�的本地化策略集�Q�locale�Q�去�Ȁ�z�（imbue�Q�之�Q�流在读回宽串wstr的时候，��是char到wchar_t的�{换，�q�且因�ؓ�Ȁ�z�M��sys_loc�Q�所以实现标准窄到宽的�{换�?br>在宽到窄的�{化中�Q�我们先打开的是宽文件流wofs�Q��ƈ且用�pȝ��的本地化�{�略集sys_loc�Ȁ�z�（imbue�Q�之�Q�这时候，因�ؓ要写的文件cvt_buf是一个外部编码，所以执行了从wchar_t到char的标准�{换。读回来的文件流从char到char�Q�不做�Q何�{换�?

lf426 2010-06-26 16:40 发表评论

��d��解密C++宽字�W�：4、利用codecvt和use_facet转换

lf426 — Sat, 26 Jun 2010 05:39:00 GMT

<本文PDF文档下蝲>

locale和facet

C++的locale框架比C更完备。C++除了一个笼�l�本地策略集locale�Q�还可以为locale指定具体的策略facet�Q�甚臛_��以用自己定义的facet��L��造一个现有的locale产生一个新的locale。如果有一个facet�c�NewFacet需要添加到某个old_loc中�Ş成新new_loc�Q�需要另外一个构造函敎ͼ�通常的做法是�Q?br>std::locale new_loc(old_loc, new NewFacet);
标准库里的标准facet都具有自��q��有的功能�Q�访问一个locale对象中特定的facet需要��用模板函数use_facet�Q?br>template const Facet& use_factet(const locale&);
换一�U�说法，use_facet把一个facet�c�d��例化成了对象�Q�由此就可以使用�q�个facet对象的成员函数�?br>
codecvt

codecvt��是一个标准facet。在C++的设计框枉��Q�这是一个通用的代码�{换模李쀔—也��是��_��q�不是仅仅�ؓ宽窄转换制定的�?br>templat class std::codecvt: public locale, public codecvt_base{...};
I表示内部�~�码�Q�E表示外部�~�码�Q�State是不同�{换方式的标识�Q�如果定义如下类型：
typedef std::codecvt CodecvtFacet;
那么CodecvtFacet��是一个标准的宽窄转换facet�Q�其中mbstate_t是标准宽�H��{换的State�?br>
内部�~�码和外部编�?br>
我们考虑�W?节中提到的C++�~�译器读取源文�g时候的情�Ş�Q�当��d��L"中文abc"的时候，外部�~�码�Q�也��是源文件的�~�码�Q�是GB2312或者UTF-8的char�Q�而编译器必须��其��译为UCS-2BE或者UTF-32BE的wchar_t�Q�这也就是程序的内部�~�码。如果不是宽字符�Ԍ��内外�~�码都是char�Q�也��׃��需要�{换了。类似的�Q�当C++��d��文�g的时�?�Q�就会可能需要到内外�~�码转换。事实上�Q�codecvt��正是被文�g��缓存basic_filebuf所使用的。理解这一点很重要�Q�原因会在下一��节看到�?br>
CodecvtFacet的in()和out()
因�ؓ在CodecvtFacet中，内部�~�码讄��为wchar_t�Q�外部编码设�|��ؓchar�Q��{换模式是标准宽窄转换mbstate_t�Q�所以，�c�L��法in()��是从char标准转换到wchar_t�Q�out()��是从wchar_t标准转换到char。这��成了我们正需要的内外转换函数�?br>result in(State& s, const E* from, const E* from_end, const E*& from_next, I* to, I* to_end, I*& to_next) const;
result out(State& s, const I* from, const I* from_end, const I*& from_next, E* to, E* to_end, E*& to_next) const;
其中�Q�s是非const引用�Q�保存着转换位移状态信息。这里需要重点强调的是，因�ؓ转换的实际工作交�l�了�q�行时库�Q�也��是��_��转换可能不是在程序的主进�E�中完成的，而�{换工作依赖于查询s的��|��因此�Q�如果s在�{换结束前析构�Q�就可能抛出�q�行时异常。所以，最安全的办法是�Q�将s讄��为全局变量�Q?br>const�?个指针分别是待�{换字�W�串的�v点，�l�点�Q�和出现错误时候的停点�Q�的下一个位�|�）�Q�另�?个指针是转换目标字符串的��L��Q�终点以及出现错误时候的停点�Q�的下一个位�|�）�?br>
代码如下�Q?br>头文�?br>

//Filename string_wstring_cppcvt.hpp

#ifndef STRING_WSTRING_CPPCVT_HPP
#define STRING_WSTRING_CPPCVT_HPP

#include <iostream>
#include <string>

const std::wstring s2ws(const std::string& s);
const std::string ws2s(const std::wstring& s);

#endif

实现�Q?br>

#include "string_wstring_cppcvt.hpp"

mbstate_t in_cvt_state;
mbstate_t out_cvt_state;

const std::wstring s2ws(const std::string& s)
{
    std::locale sys_loc("");

    const char* src_str = s.c_str();
    const size_t BUFFER_SIZE = s.size() + 1;

    wchar_t* intern_buffer = new wchar_t[BUFFER_SIZE];
    wmemset(intern_buffer, 0, BUFFER_SIZE);

    const char* extern_from = src_str;
    const char* extern_from_end = extern_from + s.size();
    const char* extern_from_next = 0;
    wchar_t* intern_to = intern_buffer;
    wchar_t* intern_to_end = intern_to + BUFFER_SIZE;
    wchar_t* intern_to_next = 0;

    typedef std::codecvt<wchar_t, char, mbstate_t> CodecvtFacet;

    CodecvtFacet::result cvt_rst =
        std::use_facet<CodecvtFacet>(sys_loc).in(
            in_cvt_state,
            extern_from, extern_from_end, extern_from_next,
            intern_to, intern_to_end, intern_to_next);
    if (cvt_rst != CodecvtFacet::ok) {
        switch(cvt_rst) {
            case CodecvtFacet::partial:
                std::cerr << "partial";
                break;
            case CodecvtFacet::error:
                std::cerr << "error";
                break;
            case CodecvtFacet::noconv:
                std::cerr << "noconv";
                break;
            default:
                std::cerr << "unknown";
        }
        std::cerr    << ", please check in_cvt_state."
                    << std::endl;
    }
    std::wstring result = intern_buffer;

    delete []intern_buffer;

    return result;
}

const std::string ws2s(const std::wstring& ws)
{
    std::locale sys_loc("");

    const wchar_t* src_wstr = ws.c_str();
    const size_t MAX_UNICODE_BYTES = 4;
    const size_t BUFFER_SIZE =
                ws.size() * MAX_UNICODE_BYTES + 1;

    char* extern_buffer = new char[BUFFER_SIZE];
    memset(extern_buffer, 0, BUFFER_SIZE);

    const wchar_t* intern_from = src_wstr;
    const wchar_t* intern_from_end = intern_from + ws.size();
    const wchar_t* intern_from_next = 0;
    char* extern_to = extern_buffer;
    char* extern_to_end = extern_to + BUFFER_SIZE;
    char* extern_to_next = 0;

    typedef std::codecvt<wchar_t, char, mbstate_t> CodecvtFacet;

    CodecvtFacet::result cvt_rst =
        std::use_facet<CodecvtFacet>(sys_loc).out(
            out_cvt_state,
            intern_from, intern_from_end, intern_from_next,
            extern_to, extern_to_end, extern_to_next);
    if (cvt_rst != CodecvtFacet::ok) {
        switch(cvt_rst) {
            case CodecvtFacet::partial:
                std::cerr << "partial";
                break;
            case CodecvtFacet::error:
                std::cerr << "error";
                break;
            case CodecvtFacet::noconv:
                std::cerr << "noconv";
                break;
            default:
                std::cerr << "unknown";
        }
        std::cerr    << ", please check out_cvt_state."
                    << std::endl;
    }
    std::string result = extern_buffer;

    delete []extern_buffer;

    return result;
}

最后补充说明一下std::use_facet(sys_loc).in()和std::use_facet(sys_loc).out()。sys_loc是系�l�的locale�Q�这个locale中就包含着特定的codecvt facet�Q�我们已�l�typedef��Z��CodecvtFacet。用use_facet对CodecvtFacet�q�行了实例化�Q�所以可以��用这个facet的方法in()和out()�?

lf426 2010-06-26 13:39 发表评论

��d��解密C++宽字�W�：3、利用C�q�行时库函数转换

lf426 — Sat, 26 Jun 2010 03:17:00 GMT

<本文PDF文档下蝲>

std::locale

通过前面两节的知识，我们知道了在C/C++中，字符�Q�串�Q�和宽字�W�（�Ԍ��之间的�{换不是简单的�Q�固定的数学关系�Q�宽�H��{换依赖于本地化策略集�Q�locale�Q�。换句话��_��一个程序在�q�行之前�q�不知道�pȝ��的本地化�{�略集是什么，�E�序只有在运行之后才通过locale获得当时的本地化�{�略集�?br>C有自��q��locale函数�Q�我们这里直接介�l�C++的locale�c�R�?br>先讨论locale的构造函敎ͼ�
locale() throw();
�q�个构造函数是获得当前�E�序的locale�Q�用法如下：
std::locale app_loc = std::locale();
或者（�q�是构造对象的两种表示方式�Q�后同）
std::locale app_loc;
另外一个构造函数是�Q?br>explicit locale(const char* name);
�q�个构造函��C��name的名字创建新的locale。重要的locale对象有：
std::locale sys_loc("");      //获得当前�pȝ��环境的locale
std::locale C_loc("C");      或�?nbsp;     std::locale C_loc = std::locale::classic();      //获得C定义locale
std::locale old_loc = std::locale::global(new_loc);      //��new_loc讄��为当前全局locale�Q��ƈ��原来的locale�q�回�l�old_loc
除了�q�些�Q�其它的name具体名字依赖于C++�~�译器和操作�pȝ��Q�比如Linux下gcc中文�pȝ��的locale名字�?zh_CN.UTF-8"�Q�中文Windows可以�?chs"�Q�更加完整的名字可以用name()函数查看�Q��?br>
mbstowcs()和wcstombs()

�q�两个C�q�行时库函数依赖于全局locale�q�行转换�Q�所以，使用前必��d��讄��全局locale�?br>std::locale已经包含�?lt;iostream>中了�Q�再加上我们需要用到的C++字符�Ԍ��所以包�?lt;string>�?br>我们先看�H�到宽的转换函数�Q?br>

const std::wstring s2ws(const std::string& s)
{
    std::locale old_loc =
        std::locale::global(std::locale(""));

    const char* src_str = s.c_str();
    const size_t buffer_size = s.size() + 1;
    wchar_t* dst_wstr = new wchar_t[buffer_size];
    wmemset(dst_wstr, 0, buffer_size);
    mbstowcs(dst_wstr, src_str, buffer_size);
    std::wstring result = dst_wstr;
    delete []dst_wstr;

    std::locale::global(old_loc);

    return result;
}

我们��全局locale讄��为系�l�locale�Q��ƈ保存原来的全局locale在old_loc中�?br>在制定�{换空间缓存大��的时候，考虑如下�Q�char是用1个或多个对象�Q�也��是1个或者多个字节来表示各种�W�号�Q�比如，GB2312�?个字节表�C�数字和字母�Q?个字节表�C�汉字；UTF-8用一个字节表�C�数字和字母�Q?个字节表�C�汉字，4个字节表�C�Z��些很��用到的�W�号�Q�比如音乐中G大调�W�号�{�。wchar_t是用1个对象（2字节或�?字节�Q�来表示各种�W�号。因此，表示同样的字�W�串�Q�宽字符串的大小�Q�也��是wchar_t对象的数量）��L��于或者等于窄字符串大��（char对象数量�Q�的�?1是�ؓ了在最后预留一个��gؓ0的对象，以便让C风格的char或者wchar_t字符串自动截断——这当然是宽串大��等于窄串大��的时候才会用上的�Q�大部分时候，字符串早在前面某个�{换完毕的位置��p��0值对象所截断了�?br>最后我们将全局locale讄��回原来的old_loc�?br>�H�串到宽串的转换函数�Q?br>

const std::string ws2s(const std::wstring& ws)
{
    std::locale old_loc =
        std::locale::global(std::locale(""));

    const wchar_t* src_wstr = ws.c_str();
    size_t buffer_size = ws.size() * 4 + 1;
    char* dst_str = new char[buffer_size];
    memset(dst_str, 0, buffer_size);
    wcstombs(dst_str ,src_wstr, buffer_size);
    std::string result = dst_str;
    delete []dst_str;

    std::locale::global(old_loc);

    return result;
}

�q�里考虑转换�I�间�~�存大小的策略正好相反，在最极端的情况下�Q�所有的wchar_t都需�?个char来表�C�，所以最大的可能��是4倍加1�?br>�q�两个函数在VC和gcc中都能正常运行（MinGW因�ؓ前面说到的原因不支持宽字�W�的正常使用�Q�，在VC中会�l�出不安全的警告�Q�这是告诉给那些弄不清宽�H��{换实质的人的警告�Q�对于了解到目前�q�些知识的你我来��_��q�就是啰嗦了�?

lf426 2010-06-26 11:17 发表评论

��d��解密C++宽字�W�：2、Unicode和UTF

lf426 — Fri, 25 Jun 2010 13:51:00 GMT

<本文PDF文档下蝲>

Unicode和UCS

Unicode和UCS是两个独立的�l�织分别制定的一套编码标准，但是因�ؓ历史的原因，�q�两套标准是完全一��L��。Unicode�q�个词用得比较多的原因可能是因�ؓ比较�Ҏ(gu��)��C��Q�如果没有特别的声明�Q�在本文所提及的Unicode和UCS��是一个意思。Unicode的目标是建立一套可以包含�h�c�L��有语�a�文字�W�号你想得到想不到的各种东西的编码，其编码容量甚至预留了火星语以及银河系以外语言的空间——开个玩�W�，反正��单的��_��Unicode�~�码集��够的大，如果用计��机单位来表�C�，其数量比3个字节大一些，不到4个字节�?br>
Unicode和UTF

因�ؓUnicode包含的内容太多，其编码在计算��Z��的表�C�方法就成�ؓ了一个有必要研究的问题。传�l�编码，比如标准�?位ASCII�Q�在计算��Z��的表�C�方法就是占一个字节的�?位，�q�似乎是不需要解释就�W�合大家习惯的表�C�方法。但是当今Unicode的��L��辑ֈ�32位（计算机的最��单位是字节�Q�所以大�?字节�Q�就只能臛_��?字节表示�Q�，对于大部分常用字�W�，比如Unicode�~�码只占一个字节大��的��p��字母�Q�占两个字节大小汉字�Q�都�?个字节来储存太奢侈了。另外，如果都用4字节直接表示�Q�就不可避免的出��Cؓ0的字节。而我们知道，在C语言中，0x00的字节就�?\0'�Q�表�C�的是一个字�W�串�Q�char字符�Ԍ��非wchar_t�Q�的�l�束�Q�换句话��_��C风格的char字符串无法表�C�Unicode�?br>因�ؓ�c�M��的种�U�问题，为Unicode在计��机中的�~�码�Ҏ(gu��)��出现了，�q�就是UTF�Q�所对应的，为UCS�~�码实现的方式也有自��q��说法。一般来��_��UTF-x�Q�x表示�q�套�~�码一个单位至��占用x位，因�ؓUnicode最长达�?2位，所以UTF-x通常是变长的——除了UTF-32�Q�而UCS-y表示一个单位就占用y个字节，所以能表示当今Unicode的UCS-y只有UCS-4�Q�但是因为历史的原因�Q�当Unicode�q�没那么庞大的时候，2个字节��够表�C�，所以有UCS-2�Q�现在看来，UCS-2所能表�C�的Unicode只是当今Unicode的一个子集�?br>也就是说�Q�如果某�U�编码，能根据一定的规则��法�Q�得到Unicode�~�码�Q�那么这�U�编码方式就可以�U�C��为UTF�?br>
UTF-8和Windows GB2312

UTF-8是一�?#8220;聪明”的编码，可能�?�Q?�Q?�Q?个字节表�C�。通过UTF-8的算法，每一个字节表�C�的信息都很明确�Q�这是不是某个Unicode�~�码的第一个字节；如果是第一个字节，�q�是一个几位Unicode�~�码。这�U?#8220;聪明”被称为UTF-8的自我同步，也是UTF-8成�ؓ�|�络传输标准�~�码的原因�?br>另外�Q�UTF-8也不会出�?字节�Q�所以可以表�C�Zؓchar字符�Ԍ��所以可以成为系�l�的�~�码。Linux�pȝ��默认使用UTF-8�~�码�?br>Windows GB2312一般自�U�CؓGB2312�Q�其实真正的名字应该是Windows Codepage 936�Q�这也是一�U�变长的�~�码�Q?个字节表�C�Z��l�的ASCII部分�Q�汉字部分是两个字节的GBK�Q�国标扩�Q�展�Q�，拼音声母�Q�。Codepage 936也可以表�C�Zؓchar字符�Ԍ��是中文Windows�pȝ��的默认编码�?br>我们在第1节中看到�?br>const char* s = "中文abc";
在Windows中的�~�码��是Codepage 936�Q�在Linux中的�~�码��是UTF-8�?br>需要注意的是，Codepage 936不像UTF�Q�跟Unicode没有换算的关�p�，所以只能通过“代码��?#8221;技术查表对应�?br>
UTF-16和UCS-2

UTF-16�?个字节或�?个字节表�C�。在2个字节大��的时候，跟UCS-2是一��L��。UTF-16不像UTF-8�Q�没有自我同步机�Ӟ��所以，�~�码大位在前�q�是��位在前�Q�就成了见仁见智的问题。我们在�W?节中�Q?#8220;�?#8221;的UCS-2BE�Q�因为是两个字节�Q�所以也��是UTF-16BE�Q�编码是0x4E2D�Q�这里的BE��是大位在后的意思（也就是小位在前了�Q�，对应的，如果是UCS-2LE�Q�编码就成了0x2D4E�?br>Windows中的wchar_t��是采用UCS-2BE�~�码。需要指出的是，C++标准中对wchar_t的要求是要能表示所有系�l�能识别的字�W�。Windows自称支持Unicode�Q�但是其wchar_t却不能表�C�所有的Unicode�Q�由此违背了C++标准�?br>
UTF-32和UCS-4

UTF-32在目前阶�D늭�价于UCS-4�Q�都用定长的4个字节表�C�。UTF-32同样存在BE和LE的问题。Linux的wchar_t�~�码��是UTF-32BE。在16位以内的时候，UTF-32BE的后两位�Q�前两位�?x00 0x00�Q�等价于UTF-16BE也就�{��h(hu��n)于UCS-2BE

BOM

��Z��说明一个文仉��用的是什么编码，在文件最开始的部分�Q�可以有BOM�Q�比�?xFE 0xFF表示UTF-16BE�Q?xFF 0xFE 0x00 0x00表示UTF-32LE。UTF-8原本是不需要BOM的，因�ؓ其自我同步的�Ҏ(gu��)��，但是��Z��明确说明�q�是UTF-8�Q�而不是让文本�~�辑器去猜）�Q�也可以加上UTF-8的BOM�Q?xEF 0xBB 0xBF

以上内容都讲�q�得很概略，详细信息��h��阅维基百�U�相兛_��宏V�?

lf426 2010-06-25 21:51 发表评论

��d��解密C++宽字�W�：1、从char到wchar_t

lf426 — Fri, 25 Jun 2010 06:41:00 GMT

<本文PDF文档下蝲>

“�q�个问题比你惌��中复�?#8221;
�Q�我也学下BS的风��|��虽然�q�句话是我自�׃��时想说的。^^�Q?br>
从字�W�到整数

char是一�U�整数类型，�q�句话的含义是，char所能表�C�的字符在C/C++中都是整数类型。好�Q�接下来�Q�很多文章就会�D��Z��个典型例子，比如�Q?a'的数值就�?x61。这�U�说法对吗？如果你细心的读过K&R和BS对于C和C++描述的原著，你就会马上反驳道�Q?x61只是'a'的ASCII��|��q�没有�Q何规定C/C++的char值必��d��应ASCII。C/C++甚至没有规定char占几位，只是规定了sizeof(char)�{�于1�?br>当然�Q�目前大部分情况下，char�?位的�Q��ƈ且，在ASCII范围内的��|��与ASCII对应�?br>
本地化策略集�Q�locale�Q?br>
“��?a'��译�?x61的整数�?#8221;�Q?#8220;��ASCII范围内的�~�码与char的整数值对应�v�?#8221;�Q�类��D��L��规定�Q�是特定�pȝ��和特定编译器制定的，C/C++中有个特定的名词来描�q�这�U�规定的集合�Q�本地化�{�略集（locale。也有翻译成“现场”�Q�。而翻译——也��是代码转换�Q�codecvt�Q�只是这个集合中的一个，C++中定义�ؓ�{�略�Q�facet。也有翻译�ؓ“刻面”�Q?br>
C/C++的编译策�?br>
“本地化策略集”是个很好的概念，可惜在字�W�和字符串这个层面上�Q�C/C++�q�不使用�Q�C++的locale通常只是影响��（stream�Q�）�Q�C/C++使用更直接简单的�{�略�Q�硬�~�码�?br>��单的��_��字符�Q�串�Q�在�E�序文�g�Q�可执行文�g�Q�非源文�Ӟ��中的表示�Q�与在程序执行中在内存中的表�C�Z��致。考虑两种情况�Q?br>A、char c = 0x61;
B、char c = 'a';
情况A下，�~�译器可以直接认识作为整数的c�Q�但是在情况B下，�~�译器必��d��'a'��译成整数。编译器的策略也很简单，��是直接��d��字符�Q�串�Q�在源文件中的编码数倹{��比如：
const char* s = "中文abc";
�q�段字符串在GB2312�Q�Windows 936�Q�，也就是我们的windows默认中文�pȝ��源文件中的编码�ؓ�Q?br>0xD6   0xD0   0xCE 0xC4 0x61 0x62 0x63
在UTF-8�Q�也��是Linux默认�pȝ��源文件中的编码�ؓ�Q?br>0xE4   0xB8   0xAD   0xE6   0x96   0x87   0x61   0x62   0x63
一般情况下�Q�编译器会忠实于源文件的�~�码为s赋��|��例外的情冉|��如VC会自作聪明的把大部分其他�c�d��~�码的字�W�串转换成GB2312�Q�除了像UTF-8 without signature�q�样的幸存者）�?br>�E�序在执行的时候，s也就保持是这��L��~�码�Q�不会再做其他的转换�?br>
宽字�W?wchar_t
正如char没有规定大小�Q�wchar_t同样没有标准限定�Q�标准只是要求一个wchar_t可以表示��M��pȝ��所能认识的字符�Q�在win32中，wchar_t�?6位；Linux中是32位。wchar_t同样没有规定�~�码�Q�因为Unicode的概忉|��们后面才解释�Q�所以这里只是提一下，在win32中，wchar_t的编码是UCS-2BE�Q�而Linux中是UTF-32BE�Q�等价于UCS-4BE�Q�，不过��单的��_��?6位以内，一个字�W�的�q?�U�编码值是一��L��。因此：
const wchar_t* ws = L"中文abc";
的编码分别�ؓ�Q?br>0x4E2D   0x6587    0x0061   0x0062   0x0063                                                //win32�Q?6�?br>0x00004E2D   0x00006587    0x00000061   0x00000062   0x00000063        //Linux�Q?2�?br>大写的L是告诉编译器�Q�这是宽字符丌Ӏ�所以，�q�时候是需要编译器�Ҏ(gu��)��locale来进行翻译的�?br>比如�Q�在Windows环境中，�~�译器的��译�{�略是GB2312到UCS-2BE�Q�Linux环境中的�{�略是UTF-8到UTF-32BE�?br>�q�时候就要求源文件的�~�码与编译器的本地化�{�略集中代码��译的策略一��_��例如VC只能��d��GB2312的源代码�Q�这里还是例外，VC太自作聪明了 �Q�会��很多其他代码在�~�译时自动�{换成GB2312�Q�，而gcc只能��d��UTF-8的源代码�Q�这里就有个��尬�Q�MinGW�q�行win32下，所以只有GB2312�pȝ��才认�Q�而MinGW却用gcc�~�写�Q�所以自己只认UTF-8�Q�所以结果就是，MinGW的宽字符被废掉了�Q��?br>宽字�W�（�Ԍ��q��译器��译�Q�还是被��编码进�E�序文�g中�?

lf426 2010-06-25 14:41 发表评论

lf426 — Thu, 10 Jun 2010 03:03:00 GMT

设计一�D�|��C�程序：打印n个数字，然后指定擦掉其中的某一个，重新打印剩下的数字�?/p>

#include <iostream>
#include <vector>

using std::cout;
using std::cin;
using std::endl;
using std::vector;

int main(int argc, char* argv[])
{
    const int MAX = 10;
    vector<int> v;
    for (int i = 0; i < MAX; i++) {
        v.push_back(i);
        cout << v[i] << '\t';
    }

    int ers = -1;
    while ( ers < 0 || ers >= MAX) {
        cout << "Erase No.";
        cin >> ers;
    }

    for (vector<int>::const_iterator i = v.begin(); i != v.end(); i++) {
        if (*i == ers) {
            v.erase(i);
        }
    }

    for (vector<int>::const_iterator i = v.begin(); i != v.end(); i++) {
        cout << *i << '\t';
    }
    cout << endl;

    return 0;
}

�q�个�E�序看似没什么错误，可以��利�~�译�Q�也可以��利�q�行�Q�甚臻I��大部分情况下可可以正常完成�?br>我们�q�里讄��的n�?0�Q�MAX�Q�，事实上，我们擦掉0�?都没有问题，但是�Q�我们要擦掉9的时候，�E�序却出错了�Q?br>在我们遍历查扑֯��{�值的循环中，一开始v.end()指向�W?0个元素（数��gؓ9�Q�的后面一个位�|�（不存在的�W?1个元素的位置�Q�。当�q�代器指向第10个元素（数��gؓ9�Q�的时候，v.erase()生效�q�行�Q�下一轮��@环中�Q��P代器本来应该指向�W?1个元素的位置�Q��ƈ且等于v.end()�q�结束��@环。但是，因�ؓ我们擦掉了vector中的一个元素，v.end()指向的是现在的最后一个元素——第9个元素的后面�Q�也��是�W?0个元素的位置。这��P��q�代器到�?1�Q�而判断确是其是否�?0�Q�这��永�q�无法实玎ͼ�形成了一个逻辑bug�Q�所以系�l�抛出错误了�?br>一个修正的办法是把需要擦掉的�q�代器找出来�Q�在循环�l�束后再擦掉�Q�下面修改后的程序就可以正常的擦�?了�?br>

#include <iostream>
#include <vector>

using std::cout;
using std::cin;
using std::endl;
using std::vector;

int main(int argc, char* argv[])
{
    const int MAX = 10;
    vector<int> v;
    for (int i = 0; i < MAX; i++) {
        v.push_back(i);
        cout << v[i] << '\t';
    }

    int ers = -1;
    while ( ers < 0 || ers >= MAX) {
        cout << "Erase No.";
        cin >> ers;
    }

    vector<int>::const_iterator ers_i;
    for (vector<int>::const_iterator i = v.begin(); i != v.end(); i++) {
        if (*i == ers) {
            ers_i = i;
        }
    }
    v.erase(ers_i);

    for (vector<int>::const_iterator i = v.begin(); i != v.end(); i++) {
        cout << *i << '\t';
    }
    cout << endl;

    return 0;
}

lf426 2010-06-10 11:03 发表评论

用对象的成员函数引出�U�程�Q�还是在�U�程中创建对象？

lf426 — Sat, 05 Jun 2010 13:06:00 GMT

�q�是先看一�D�非多线�E�的�E�序。我们用TestClass1表示在线�E�中创徏的对象类�Q�用TestClass2表示与创建线�E�的操作在同一定义域（也就是同一对{}之中的）的局部变量的对象�c�R�?br>之所以提出TestClass2�q�种�c�，是因为在实际�~�程中我们会遇到�q�种情况�Q�我们不可预知这个类何时创徏以及创徏多少�Q�这个类的对象是一个新�U�程的参数。比如，在sokcet中的TCP server端就会有�q�种情况�Q�如果每一个新�q�接的client都用创徏一个新的线�E�去处理�Q�我们不可预知在什么时候会有多��客��L��q�过来�?br>我们先观察没有多�U�程的时候对象的生命周期�Q?br>

#include <iostream>
#include "windows.h"

class TestClass1{
private:
    int x;
public:
    explicit TestClass1(int to_x):x(to_x)
    {}
    ~TestClass1()
    {
        std::cerr << "destruction: 1." << std::endl;
    }
    void show() const
    {
        std::cerr << x << std::endl;
    }
};

class TestClass2{
private:
    int* pX;
public:
    explicit TestClass2(int to_x)
    {
        pX = new int;
        *pX = to_x;
    }
    ~TestClass2()
    {
        delete pX;
        std::cerr << "destruction: 2."  << std::endl;
    }
    const int& value() const
    {
        return *pX;
    }
};

DWORD WINAPI thread_func(LPVOID pN)
{
    Sleep(200);
    TestClass1 test((*((TestClass2*)pN)).value());
    test.show();
    return 0;
}

int main(int argc, char* argv[])
{
    for (int i = 0; i < 3; ++i) {
        TestClass2 n(5);

        thread_func((LPVOID)&n);
        std::cerr << "loop: " << i+1 << std::endl;
    }

    Sleep(2000);

    std::cout << "main() ok." << std::endl;

    return 0;
}

�q�是标准的C++模式�Q�对象的生命周期是可以预见的�Q?br>

5
destruction: 1.
loop: 1
destruction: 2.
5
destruction: 1.
loop: 2
destruction: 2.
5
destruction: 1.
loop: 3
destruction: 2.
main() ok.
��h��L��键��l? . .

如果我们�Ҏ(gu��)��U�程调用�Q?br>

#include <iostream>
#include "windows.h"

class TestClass1{
private:
    int x;
public:
    explicit TestClass1(int to_x):x(to_x)
    {}
    ~TestClass1()
    {
        std::cerr << "destruction: 1." << std::endl;
    }
    void show() const
    {
        std::cerr << x << std::endl;
    }
};

class TestClass2{
private:
    int* pX;
public:
    explicit TestClass2(int to_x)
    {
        pX = new int;
        *pX = to_x;
    }
    ~TestClass2()
    {
        delete pX;
        std::cerr << "destruction: 2."  << std::endl;
    }
    const int& value() const
    {
        return *pX;
    }
};

DWORD WINAPI thread_func(LPVOID pN)
{
    Sleep(200);
    TestClass1 test((*((TestClass2*)pN)).value());
    test.show();
    return 0;
}

int main(int argc, char* argv[])
{
    for (int i = 0; i < 3; ++i) {
        TestClass2 n(5);

        HANDLE hThrd;
        DWORD thrdId;
        hThrd = CreateThread(    NULL,
                                0,
                                thread_func,
                                (LPVOID)&n,
                                0,
                                &thrdId);

        std::cerr << "loop: " << i+1 << std::endl;
    }

    Sleep(2000);

    std::cout << "main() ok." << std::endl;

    return 0;
}

可以看到函数�q�回了错误的��|��至于��Z��么每�ơ都�?6我还不清楚，但是臛_��不是正确的数�?�Q�，�q�是因�ؓ在线�E�调用TestClass2的对象之前已�l�被析构的缘故�?br>

loop: 1
destruction: 2.
loop: 2
destruction: 2.
loop: 3
destruction: 2.
36
destruction: 1.
36
destruction: 1.
36
destruction: 1.
main() ok.
��h��L��键��l? . .

所以，如果我们设想构造一个类�Q�这个类的对象可以调用包含this的线�E�，那么�q�个对象一定不能是局部变量，或者说�Q�我们必��d��循环的{}对之前先把这些对象构造出来。这与我们的需求不�W�合——我们�ƈ不知道需要多��对象以及如何构造（比如构造TCP的通讯socket需要accept()接受客户端的信息�Q�，在这�U�情况下�Q�我们只能在�U�程中去构造对象，�q�样的对象生命周期跟�U�程函数一栗��?br>或者说�Q�如果我们希望用�c�L��装�U�程�Q�那么这些可以调用线�E�的对象必须是全局的。相兛_��容请参考本人前面的教程“初试多线�E?#8221;�{��?

lf426 2010-06-05 21:06 发表评论

lf426 — Sat, 05 Jun 2010 12:16:00 GMT

以下以win32�q�_��Z��。我们先看一个非多线�E�的�E�序�Q?br>

#include <iostream>
#include <windows.h>

DWORD WINAPI thread_func(LPVOID pN)
{
    for (int i = 0; i < *((int*)pN); ++i) {
        std::cout << i+1 << "\t";
    }
    std::cout << std::endl;
    throw "ok.";

    std::cout << "thread_func() done." << std::endl;
    return 0;
}

int main(int argc, char* argv[])
{
    int n = 5;

    try{
    thread_func((LPVOID)&n);
    Sleep(2000);
    }
    catch (const char* s) {
        std::cerr << s << std::endl;
        exit(1);
    }

    std::cout << "main() done." << std::endl;

    return 0;
}

可以看到�Q�函数thread_func()可以正确的抛出异常�ƈ被main()的catch捕捉。但是，如果用一个新�U�程来运行thread_func()会出��C��么情况呢�Q?br>

#include <iostream>
#include <windows.h>

DWORD WINAPI thread_func(LPVOID pN)
{
    for (int i = 0; i < *((int*)pN); ++i) {
        std::cout << i+1 << "\t";
    }
    std::cout << std::endl;
    throw "ok.";

    std::cout << "thread_func() done." << std::endl;
    return 0;
}

int main(int argc, char* argv[])
{
    HANDLE hThrd;
    DWORD thrdId;
    int n = 5;

    try{
    hThrd = CreateThread(    NULL,
                            0,
                            thread_func,
                            (LPVOID)&n,
                            0,
                            &thrdId);
    Sleep(2000);
    }
    catch (const char* s) {
        std::cerr << s << std::endl;
        exit(1);
    }

    std::cout << "main() done." << std::endl;

    return 0;
}

很不�q�，�q�个�E�序�~�译的时候是可以通过的，但是�q�行时出错：

1 2 3 4 5

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
��h��L��键��l? . .

而且同时会有一个运行时错误的提�C�。事实上�Q�这个错误提�C�意味着�E�序在没有发现try{}的时候看��C��throw�?br>通过试验�Q�我发现�pȝ��Q�这里是win32�Q�不能将CreateThread()所产生的线�E�归�l�到try{}中。更加严重的情况是，即��用一个函数囊括了整个�E�序�Q�然后try�q�个函数�Q�其他线�E�依然脱��M��q�个try�?br>所以，一个解��x��法是�Q�凡是遇到新的线�E�，必须在新�U�程中重新写异常处理。不�Ӟ��如google代码标准里所说的那样�Q�不使用C++的异常机制。毕竟C++没有定义多线�E�的标准�Q�所以也��无从说起多�U�程中异常处理的标准�?br>最后附上在新线�E�写异常处理的参考：

#include <iostream>
#include <windows.h>

DWORD WINAPI thread_func(LPVOID pN)
{
    try{
    for (int i = 0; i < *((int*)pN); ++i) {
        std::cout << i+1 << "\t";
    }
    std::cout << std::endl;
    throw "ok.";
    }
    catch (const char* s) {
        std::cerr << s << std::endl;
        exit(1);
    }

    std::cout << "thread_func() done." << std::endl;
    return 0;
}

int main(int argc, char* argv[])
{
    HANDLE hThrd;
    DWORD thrdId;
    int n = 5;

    hThrd = CreateThread(    NULL,
                            0,
                            thread_func,
                            (LPVOID)&n,
                            0,
                            &thrdId);
    Sleep(2000);

    std::cout << "main() done." << std::endl;

    return 0;
}

lf426 2010-06-05 20:16 发表评论

lf426 — Sat, 26 Apr 2008 04:39:00 GMT

游戏的设计离不开多线�E�，在C++新标准出来之前，多线�E�的设计�q�是多以依赖特定�pȝ��的函数库或者某些特定的函数库�ؓ主，如同SDL�Q�打开多线�E�的函数也主要是C函数。我们当然很期待boost中真正意义上的C++多线�E�类的加入，不过仍然需要等待。问题就出在打开多线�E�的C函数上，因�ؓ他们通常调用的是函数指针�Q�但是在C++中，我们通常把函数绑定到了与其数据相关的�c�M��Q�也��是��_��我们在C++中很��用�?#8220;单��n”的函敎ͼ�成员函数可以被那些调用函数指针的启动多线�E�的函数调用吗？
�{�案是：通常不行�Q�但是静态成员函��C��外�?br> 在C++中，函数指针与成员函数指针完全是两个概念�Q��ƈ且相互之间在��M��情况下，无法转换�Q?br> 我们来看�q�么一个类�Q?br>

#include <iostream>

class A
{
private:
    int a;
public:
    A(int _a): a(_a)
    {}
    void f1() const
    {
        std::cout << "call f1, a = " << a << std::endl;
    }
    int f2() const
    {
        std::cout << "call f2, a = " << a << std::endl;
        return 0;
    }
    static void f3(const A& _a)
    {
        std::cout << "call f3, ";
        _a.f1();
    }
    friend void f4(const A& _a)
    {
        std::cout << "call f4, a = " << _a.a << std::endl;
    }
};

其中函数A::f1()和A::f2()是毫无疑问的成员函数�Q�A::f3()也是成员函数�Q�但是他是静态成员函敎ͼ�f4()是A�cȝ��友元函数�Q�他实际上就是一个普通的函数�?br>A::f1()的指针我们需要这样定义：

typedef void (A::*pcf)()const;

作�ؓ参数的时候必��这样写“&A::f1”�?br>A::f2()的指针我们这样定义：

typedef int (A::*ptf)()const;

��管A::f2()与A::f1()的返回类型不同，但是他们的�Ş参列表是一��L��Q�所以，指针可以通过强制转换�q�行转换�?br>如果他们的�Ş参列表不一��_��则强制�{换在�~�译期间没有问题�Q�但是运行时会抛出异常�?br>�q�是因�ؓ形参列表不一��h��味着强制转换后，某些函数无法得到某些必须的参数。所以，�q�种转换应该是需要避免的�?br>A::f3()和f4()��管一个是静态成员函敎ͼ�一个是普通函敎ͼ�但是他们的指针定义却是一��L��Q?br>

typedef void (*pf)(const A&);

�q�也��是��Z��么调用函数指针的函数可以直接调用静态成员函数指针的原因�?br>作�ؓ参数的时候，他们既可以加�?#8220;&”来写�Q?#8220;&A::f3”, “&f4”�Q?br>也可以不�?#8220;&”�Q?#8220;A::f3”, “f4”�?br>�q�是在A�c�d��义域外的情况。在A定义域内�Q�比如在写A的成员函数的时候，静态成员函数甚臛_��以不需要加上A的定义域�W�号“A::”�Q�直接可以��?#8220;&f3”或�?#8220;f3”�?br>
我们把剩下的�E�序补充完整�Q?br>

void call_A(pcf pF, const A& _a)
{
    (_a.*pF)();
}

void call_A(pf pF, const A& _a)
{
    (*pF)(_a);
}

int main(int argc, char* argv[])
{
    A a(10);

    call_A(&A::f1, a);

    ptf __f2 = &A::f2;
    pcf _f2 = (pcf)(__f2);
    call_A(_f2, a);

    call_A(A::f3, a);

    call_A(f4, a);

    return 0;
}

可以看到的情冉|��Q?br>1、成员函数的指针与对象是不绑定的。也��是��_��管我也很希望如果a是A的对象，a.f1()的指针要是能表示成a.f1�Q�或�?#8220;&(a.f1)”�Q�多好？但是�q�是不允许的�Q�至��现在是不允许的。我们要调用A::f1()�Ҏ(gu��)��Q�还得指定其对象�Q�所以，�q�实际上与调用静态成员函��C��普通函数是一��L��?br>2、静态成员函数可以代替普通函数被调用函数指针�Q�非成员函数指针�Q�的函数调用。但是静态成员函数有一个好处，��是可以被类�U�有保护��h��——当�Ӟ��最好是有其他公共成员将其作用对外连接�v来的时候�?

lf426 2008-04-26 12:39 发表评论

成员数据的三�U��Ş式与栈对象的生命周期

lf426 — Mon, 14 Apr 2008 04:36:00 GMT

假设我们有一个类A�Q�另外一个类B中有个成员数据是A的对象，我们如何来定义这个成员数据呢�Q?br>最直接的，我们可以��把它定义�ؓA的对象：A a_obj;
其次�Q�我们可以把它定义�ؓA对象的引用：A& a_obj; 或者const引用�Q�const A& a_obj;
再者，我们�q�可以把它定义�ؓA对象的指针：A* pA_obj; 或者const对象的指针：const A* pA_obj;
当我们直接��用A对象的时候，a_obj会在B对象建立的时候徏立，在B销毁的时候销毁。因��是一个新建立的对象，所以在成员初始化的时候是真正构造了对象�Q�即我们前面说到的��用了复制构造函数�?br> 如果使用的是A对象的引用或者指针，a_obj�Q�或pA_obj�Q�都没有构造新的对象。我们假设B的一个构造函数是�q�样的：B(const A& a_obj): a_obj(a_obj) {}�Q�那么毫无疑问，�q�个构造函数是能正常工作的�Q�也��是��_��我们用现成的对象�Q�或者说是在B对象生命周期内都会一直存在的A对象��L��造B对象是没有问题的。但是，如果一个构造函数是�q�样的：B(int a): a_obj(A(a)) {}�Q�这个函敎ͼ�一般在�~�译的时候是不会报错或者发��告的�Q�但是我们分析一下，A(a)是��时构造了一个A对象�Q�然后a_obj成�ؓ了这个��时对象的引用。但是问题是�Q�这个��时对象在B对象构造之后就马上销毁了�Q�也��是��_��a_obj引用了一个不存在的对象（换到指针说就是指向了�I�指针）。这是一个巨大的错误�Q�将在运行时引发错误�?br> 所以，�l�论是：如果成员数据使用�Q�新�Q�对象，则必��d��义这个对象所属类的复制构造函敎ͼ�如果使用的是对象引用或者指针，则一定只能用已经存在�q�且会在B对象整个生命周期内都存在的A对象来构造这个B对象�?br> 说得貌似很复杂，留个作�ؓ例子�?个类�Q�大家可以多写几个演�C�程序试试�?br>

#ifndef A_HPP
#define A_HPP

#include <iostream>
using namespace std;

char* get_point(int lenth);
void free_point(char* temp);

class A
{
private:
    //
protected:
    char* temp;
    int lenth;
    A();
public:
    A(const A& copy);
    ~A();
    void show() const;
};

class C: public A
{
public:
    C(int _lenth);
    ~C();
};

class B
{
private:
    A b;
public:
    B(const A& a);
    B(int _lenth);
    ~B();
    void show() const;
};

#endif

#include "a.hpp"

A::A(): temp(0),lenth(0)
{
    cout<< "A Constructor!" << endl;
}

A::A(const A& copy): lenth(copy.lenth)
{
    temp = get_point(lenth);
    cout << "A Copy Constructor" << endl;
    cout << "temp at: " << int(temp) << endl;
}

A::~A()
{
    cout << "temp at: " << int(temp) << endl;
    free_point(temp);
    cout << "Heap Deleted!\n";
    cout << "A Destroyed!" << endl;
}

void A::show() const
{
    cout << temp << endl;
}

//***************************************

C::C(int _lenth): A()
{
    lenth = _lenth;
    temp = get_point(lenth);
    cout<< "C Constructor!" << endl;
    cout << "temp at: " << int(temp) << endl;
}

C::~C()
{
    cout << "C Destroyed!" << endl;
}

//***************************************

B::B(const A& a): b(a)
{
    cout<< "B Constructor!" << endl;
}

B::B(int _lenth): b(C(_lenth))
{
    cout<< "B Constructor!" << endl;
}

B::~B()
{
    cout << "B Destroyed!" << endl;
}

void B::show() const
{
    b.show();
}

//************************************

char* get_point(int lenth)
{
    char* temp = new char[lenth+1];
    for ( int i = 0; i< lenth; i++ )
        temp[i] = '*';
    temp[lenth] = '\0';
    cout << "New buffer got!\n";
    return temp;
}

void free_point(char* temp)
{
    delete []temp;
    cout << "Buffer deleted!\n";
}

lf426 2008-04-14 12:36 发表评论

lf426 — Mon, 14 Apr 2008 03:50:00 GMT

C++为我们提供了默认的复制构造函敎ͼ�赋值函数和析构函数�Q��用的全部�?#8220;��复�?#8221;�Q�即仅仅复制栈上的数据。换句话��_��如果我们涉及��C��对堆数据的操作，�q�些函数都必��L��们自己重新来写。我很郁闷�ؓ什么在�~�译的时候，C++不能自己发现构造函��C��用了堆操作，从而提醒不要��用默认的�q�三个函数。也许是因�ؓ要编译器做到��的判断很隑֐�。用new...delete或许很容易看出来�Q�但是更多的函数调用�Q�特别是涉及到C风格的函数的时候，真的很难判断哪些函数使用��C��堆操作�?br> 而这三个函数的作用可以说是巨大的�Q�析构就不说了，析构可以说是C++永远的痛。复制构造函数用得最多的地方�Q�恐怕就是成员初始化列表的时候，�q�几乎是在一个类成员数据使用到另外一个类对象时候的唯一�Ҏ(gu��)��。而赋值函数则是把数据从语句体�Q?#8220;{}”对，循环�Q�判断）中带出的最��单方法——虽然我们现在可以很方便的��用vector�?br> �q�里先说说复制构造函数吧。如果遗漏申明，又不慎用刎ͼ�比如�q�个例子�Q?/p>

#include <iostream>
#include <vector>

class A
{
private:
    int a;
public:
    A(int _a): a(_a)
    {
        std::cout << "A created!\n";
    }
/*
    A(const A& copy): a(copy.a)
    {
        std::cout << "A copy created!\n";
    }
*/
    ~A()
    {
        std::cout << "A destroyed!\n";
    }
    void show() const
    {
        std::cout << a << std::endl;
    }
};

int main(int argc, char* argv[])
{
    A a(1);
    A b(a);

    return 0;
}

那么�Q�结果运行就会出现貌似创��Z��ơ，但是却销毁了两次的假象。这当然是不可能发生的，但是郁闷的是�Q�C++中的构造和析构不��L��成对出现的，比如我们前面说到的手动显式调用析构函数的情况。所以，如果攑֜�大的��目中，�q��ؓ我们的调试带来更多的困难�?br> 所以，�l�论是，如果A�c�L��造具有堆操作�Q�有可能把A�c�M��为B�cȝ��成员数据�Q�B�c�d��有可能通过成员初始化列表构造A对象�Q�请一定别忘记手写复制构造函数�?

lf426 2008-04-14 11:50 发表评论

lf426 — Sat, 12 Apr 2008 06:29:00 GMT

几乎在大部分时候，我们是不需要显式的调用析构函数的。显式的调用析构函数是一仉��常危险的事情�Q�因为如果系�l�会调用析构函数�Q�无论我们自己是否已�l�调用过�Q�仍然会再次调用。换句话��_��我们自己所谓的昑ּ�调用析构函数�Q�实际上只是调用了一个成员函敎ͼ��q�没有真正意义上的让对象“析构”�?br> ��Z��理解�q�个问题�Q�我们必��首先弄明白“�?#8221;�?#8220;�?#8221;的概��c�?br>堆区�Q�heap�Q?nbsp;—�?一般由�E�序员分配释放，若程序员不释放，�E�序�l�束时可能由O(ji��n)S回收。注意它与数据结构中的堆是两回事�Q�分配方式倒是�c�M��于链表�?br>栈区�Q�stack�Q�—�?��q��译器自动分配释放 �Q�存攑և�数的参数��|��局部变量的值等。其操作方式�c�M��于数据结构中的栈�?br> 我们构造对象，往往都是在一�D�语句体中，比如函数�Q�判断，循环�Q�还有就直接被一�?#8220;{}”包含的语句体。这个对象在语句体中被创建，在语句体�l�束的时候被销毁。问题就在于�Q�这��L��对象在生命周期中是存在于栈上的。也��是��_��如何��理�Q�是�pȝ��完成而程序员不能控制的。所以，即��我们调用了析构，在对象生命周期结束后�Q�系�l�仍然会再调用一�ơ析构函敎ͼ��其在栈上销毁，实现真正的析构�?br> 所以，如果我们在析构函��C��有清除堆数据的语句，调用两次意味着�W�二�ơ会试图清理已经被清理过了的�Q�根本不再存在的数据�Q�这是�g会导致运行时错误的问题，�q�且在编译的时候不会告诉你�Q?br>在网上找到这几句话，说得很好啊：
//昑ּ�调用的时候，析构函数相当于的一个普通的成员函数
//�~�译器隐式调用析构函敎ͼ�如分配了对内存，昑ּ�调用析构的话引�v重复释放堆内存的异常
//把一个对象看作占用了部分栈内存，占用了部分堆内存�Q�如果申请了的话�Q�，�q�样便于理解�q�个问题
//�pȝ��隐式调用析构函数的时候，会加入释放栈内存的动作（而堆内存则由用户手工的释放）
//用户昑ּ�调用析构函数的时候，只是单纯执行析构函数内的语句�Q�不会释放栈内存�Q�摧毁对�?/span>
�pȝ��在什么情况下不会自动调用析构函数呢？昄��Q�如果对象被建立在堆上，�pȝ��׃��会自动调用。一个常见的例子是new...delete�l�合。但是好在调用delete的时候，析构函数�q�是被自动调用了。很�|�见的例外在于��用布局new的时候，在delete讄��的缓存之前，需要显式调用的析构函数�Q�这实在是很��见的情��c�?br> 所以，�l�论是，一般不要自作聪明的去调用析构函数。或者要是你不嫌�ȝ��的话�Q�析构之前最好先看看堆上的数据是不是已经被释放过了。放��Z��个演�C�的例子�Q�大家可以参考一下哈�?/p>

#ifndef A_HPP
#define A_HPP

#include <iostream>
using namespace std;

class A
{
private:
    int a;
    int* temp;
    bool heap_deleted;
public:
    A(int _a);
    A(const A& _a);
    ~A();
    void change(int x);
    void show() const;
};

#endif

#include "a.hpp"

A::A(int _a): heap_deleted(false)
{
    temp = new int;
    *temp = _a;
    a = *temp;
    cout<< "A Constructor!" << endl;
}

A::A(const A& _a): heap_deleted(false)
{
    temp = new int;
    *temp = _a.a;
    a = *temp;
    cout << "A Copy Constructor" << endl;
}

A::~A()
{
    if ( heap_deleted == false){
        cout << "temp at: " << temp << endl;
        delete temp;
        heap_deleted = true;
        cout << "Heap Deleted!\n";
    }
    else {
        cout << "Heap  already Deleted!\n";
    }

    cout << "A Destroyed!" << endl;
}

void A::change(int x)
{
    a = x;
}

void A::show() const
{
    cout << "a = " << a << endl;
}

#include "a.hpp"

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

    A a(1);
    a.~A();
    a.show();
    cout << "main() end\n";
    a.change(2);
    a.show();

    return 0;
}

lf426 2008-04-12 14:29 发表评论

SDL入门教程�Q�九(ji��)�Q�：4、int转换为std::string

lf426 — Wed, 26 Mar 2008 12:48:00 GMT

作者：龙飞

我下面考虑的问题，是用TextSurface反馈鼠标事�g的信息。我惛_��的第一个例子，很自然就是反馈鼠标所在坐标的位置。这里涉及到一个基��的问题，即鼠标位�|�显然不是用字符串表�C�的。SDL�l�我们的反馈信息是int�Q�我们需要用TextSurface��int构徏成可以被blit到ScreenSurface上的面，需要做的第一件事情，是将int转换为string�?br> 我的思�\是这��L��Q�首先找到int的数位数�Q�然后依�ơ从高位��d��数字�Q�之后将�q�个位去掉（通常减掉是最��单的�Q�；依次记录�q�些数字�Q��{换成string�Q�然后将�q�些数字“�?#8221;�Q�字�W�串的合�qӞ��h��?br>头文件如下：

//UVi Soft (2008)
//Long Fei (lf426), E-mail: zbln426@163.com

//FileName: int_to_string.h

#ifndef INT_TO_STRING_H_
#define INT_TO_STRING_H_

#include <iostream>
#include <string>
#include <vector>

int int_power(int base, int exp);
std::string int_to_string(int num);

#endif

其中�Q�int_to_string()是我们需要构建的函数�Q�int_power()是求一个数的整数幂的函数。这么简单的��法�Q�我们就自己写吧。至于用到vector�Q�按照我的思�\�Q�我们需要的数据�l�构昄��应该�?#8220;队列”�Q�先�q�先出）。不�q�真得感谢STL�Q�用vector昄��不是最优化的，但是肯定是最“通俗”的，因�ؓ即��是作为非专业的队列（或者栈�Q�，vector也已�l��ؓ我们提供了必要的�Ҏ(gu��)��Q�比如推入（push_back�Q��?br> 下面我就把程序说明夹在程序中间了。原因是本�h��p��太菜�Q�简单描�q�还能忍�Q�描�q�算法就有点不能忍了-_-!!!。另外，��管我英语这水��^�Q�我�q�是希望�E�序里面别用中文注释的好。这�U�事情，�(zh��n)�见�q�一�ơ�ؕ码，��L��得恶心一辈子�?br>

//UVi Soft (2008)
//Long Fei (lf426), E-mail: zbln426@163.com

#include "int_to_string.h"

int int_power(int base, int exp)
{
    int result = 1;
    for (int i = exp; i > 0; i-- )
        result*=base;
    return result;
}

�q�是个很��单的求幂的算法。其实我们在�E�序中，只需要用到求10的n�ơ幂�Q�所以，实际上我们还可以写得更加有针对一炏V�?br>

std::string int_to_string(int num)
{
    bool negative = false;
    if ( num < 0 ){
        negative = true;
        num = -num;
    }

�q�开始写转换函数了。首先我们判定int是否��。如果是�Q�我们把它变成其相反敎ͼ�然后与正��C��栯��{换，最后在前面加上“-”��O(ji��n)K了�?br>

    int bitNum = 1;
    for ( int i = num; i > 9; i/=10 )
        bitNum++;

bitNum是这个int的数位数。比�?��是1位，1024��是4位�?br>

    std::vector<int> eachNum;
    for ( int i = bitNum, temp = num; i > 0; i-- ){
        int highBit = int(temp/int_power(10, (i-1)));
        eachNum.push_back(highBit);
        temp-=(highBit*int_power(10, (i-1)));
    }

我们通过vector数组�U�录每个��C��上的数字�Q�从高位��C��位。需要说明的是，n位的数字�?0的n-1�ơ方�q�。比�?024�?位，�?000�?0�?�ơ方�q�。所以，我们�q�里用的是i-1而非i�?br>

    std::string str;
    if ( negative == true )
        str = "-";
    for ( std::vector<int>::iterator pTemp = eachNum.begin(); pTemp != eachNum.end(); pTemp++ ){
        switch ( *pTemp ){
            case 0:
                str+="0";
                break;
            case 1:
                str+="1";
                break;
            case 2:
                str+="2";
                break;
            case 3:
                str+="3";
                break;
            case 4:
                str+="4";
                break;
            case 5:
                str+="5";
                break;
            case 6:
                str+="6";
                break;
            case 7:
                str+="7";
                break;
            case 8:
                str+="8";
                break;
            case 9:
                str+="9";
                break;
            default:
                break;
        }
    }
    return str;
}

最后，我们用了STL的方法将每个数字转换成std::string的字�W�串�Q�然后将�q�些字符串合�q��v来，作�ؓ函数的返回倹{�?br> 我们在下一节中��用TextSurface演示�q�个函数的作用，以及实现我们在本节前面所提出的问题�?

lf426 2008-03-26 20:48 发表评论

从“集合”实例分析修饰函数返回值的const作用

lf426 — Thu, 13 Mar 2008 05:30:00 GMT

�q�段旉��在复习C++基础�Q�算法与数据�l�构�Q�以及学习STL。所以，SDL的教�E�更��C��慢些。因为我�q�是以自��q��目为核心进行学习的�Q�所以基��知识和游戏设计涉及到囑�Ş�Q�控制和多线�E�的内容学习�Q�应该是会有些交叉的�?br> 发现�q�个问题�Q�是因�ؓ一直以来思考的一个算法——关�?#8220;集合”的实现。这个集合就是数学中的集合，与计��机中数列一个最大的不同在于�Q�集合的元素是互异的。因��两天在熟�(zh��n)�vector�Q�所以觉得用vector实现集合再合适不�q�了。STL��实是很好很强大的体�p�，无论是内存管理，�q�是链表的实玎ͼ�让我们可以省很多心。其实关于�ؓ什么要实现集合�Q�也是因为我在计划实现类��D��雄无敌战��移动的一�p�d��法中，很多地方会用到集合的概念�Q�甚臛_��括�ƈ集和差集�{�等。也许我惛_��的算法是很笨拙的�Q�但是在我还没有完全阅读相关的已有代码之前，觉得完全凭自��q��认识�Q�实现这些算法还是很有意义的�Q�所以，从学习C++的第一天开始，我就在试图找到解册��些问题的�Ҏ(gu��)��Q�而现在，��来��清��C��Q�呵��c�?br> 我的思�\很直接也很简单，��是把一个数�l�中的元素往一个新的数�l�中填，新填充的元素会遍历新数组中已有的元素�Q�如果与之互异，则填入（push�Q�，否则��p��C��一个。以上就已经��立了成员数据（�U�有�Q�和构造函数。因为我们需�?#8220;集合�?#8221;了的数组是可以被外部讉K��的，所以一个最��单的�Ҏ(gu��)��是把成员数据公有——这��实是很��单，而且�q�样��׃��会出��C��天我们要讨论的问题了�Q�另外一个笨办法是用一个公有方法，�q�回成员数据的值——我��是�q�么做的�Q�因��貌似更符合OOP�?#8220;数据隐藏”的精��?_-!!!。很快可以写出头文�g�Q?br>

#ifndef AGGREGATE_H_
#define AGGREGATE_H_

#include <iostream>
#include <vector>
#include <algorithm>

class Aggregate
{
private:
    std::vector<int> agg;
public:
    Aggregate(std::vector<int>& temp);
    const std::vector<int> getAgg() const;
};

#endif

��h��意那个红色的const�Q�其实我惌��的是�Q�第一�ơ写�q�个�E�序的时候，我�ƈ没有�q�个const。一直以来，除了在重�?#8220;=”的时候我大概清楚修饰�q�回值const的作用是可以避免让返回值做左��|��其他时候还真不太明白这个const的作用，只是本着C++的精��——能const��const�?_-!!!。实现文�Ӟ��

#include "aggregate.h"

Aggregate::Aggregate(std::vector<int>& temp)
{
    for ( std::vector<int>::iterator pTemp = temp.begin(); pTemp != temp.end(); pTemp++ ) {
        bool findSame = false;
        for ( std::vector<int>::iterator pAgg = agg.begin(); pAgg != agg.end(); pAgg++ )
            if ( *pTemp == *pAgg )
                findSame = true;
        if ( findSame == false )
            agg.push_back(*pTemp);
    }
}

const std::vector<int> Aggregate::getAgg() const
{
    return agg;
}

一切都很完��，不是吗？��手��q��l�写��Z��个测试用的程序：

#include "aggregate.h"

void show(int& i);

int main(int argc, char* argv[])
{
    std::vector<int> tempArray;
    int temp;
    bool goon = true;

    while ( goon == true ) {
        std::cout << "#" << tempArray.size()+1 << "= ";
        std::cin >> temp;
        if ( temp == -1 ) {
            goon = false;
            continue;
        }
        tempArray.push_back(temp);
    }

    std::cout << "You've entered " << tempArray.size() << " numbers." << std::endl;

    for_each(tempArray.begin(), tempArray.end(), show);

    std::cout << "----------------------------\n" << "Now, to be aggregate\n";

    Aggregate tempAgg (tempArray);
    std::cout << "There are " << tempAgg.getAgg().size() << " different numbers.\n";
    for_each(tempAgg.getAgg().begin(), tempAgg.getAgg().end(), show);

    return 0;
}

void show(int& i)
{
    std::cout << i << std::endl;
}

很不�q�，�~�译正常的通过了（注意�Q�没有红色的const的时候）�?br>但是�Q�运行时出现了错误�?br>�q�行旉��误是件��o人很郁闷的事情，因�ؓ�q�意味着�~�译器不会帮你找到出错的地方�?br>�q�运的是�Q�直觉让我觉得类似tempAgg.getAgg().begin()的用法有问题�Q�所以，我改成了�Q�（紫色那部分代码）

    std::cout << "----------------------------\n" << "Now, to be aggregate\n";

    Aggregate tempAgg (tempArray);
    std::vector<int> tempAggArray = tempAgg.getAgg();
    std::cout << "There are " << tempAggArray.size() << " different numbers.\n";
    for_each(tempAggArray.begin(), tempAggArray.end(), show);

�q�样�Q�问题是解决了。但是我们回头分析一下，刚才的问题到底出在什么地方呢�Q?br>其实�Q�如果我们加上红色的const�Q��用原来的代码�q�行�~�译的时候，�~�译器是可以指出我们的错误的�Q�确实是tempAgg.getAgg().begin()的用法出了问题。具体的原因包含�?lt;algorithm>里面�Q�我没有仔细��d��析，但是我们臛_��明白了，�Ҏ(gu��)��begin()会试图修改其对象的返回��|��
让错误被发现在编译阶�D�，�q�远好于被发现在�q�行旉��D�c��我惻I��q�就是C++中const最大的作用。所以，�ȝ��h��q�是C++的一句话�Q�能const�Q�就const吧�?)

lf426 2008-03-13 13:30 发表评论