关于C++中异常的争论何其多也，但往往是一些不合事实的误解。异常曾经是一个难以用好的语言特性，幸运的是，随着C++社区经验的积累，今天我们已经有足够的知识轻松编写异常安全的代码了，而且编写异常安全的代码一般也不会对性能造成影响。

　　使用异常还是返回错误码？这是个争论不休的话题。大家一定听说过这样的说法：只有在真正异常的时候，才使用异常。那什么是“真正异常的时候”？在回答这个问题以前，让我们先看一看程序设计中的不变式原理。

　　对象就是属性聚合加方法，如何判定一个对象的属性聚合是不是处于逻辑上正确的状态呢？这可以通过一系列的断言，最后下一个结论说：这个对象的属性聚合逻辑上是正确的或者是有问题的。这些断言就是衡量对象属性聚合对错的不变式。

　　我们通常在函数调用中，实施不变式的检查。不变式分为三类：前条件，后条件和不变式。前条件是指在函数调用之前，必须满足的逻辑条件，后条件是函数调用后必须满足的逻辑条件，不变式则是整个函数执行中都必须满足的条件。在我们的讨论中，不变式既是前条件又是后条件。前条件是必须满足的，如果不满足，那就是程序逻辑错误，后条件则不一定。现在，我们可以用不变式来严格定义异常状况了：满足前条件，但是无法满足后条件，即为异常状况。当且仅当发生异常状况时，才抛出异常。

　　关于何时抛出异常的回答中，并不排斥返回值报告错误，而且这两者是正交的。然而，从我们经验上来说，完全可以在这两者中加以选择，这又是为什么呢？事实上，当我们做出这种选择时，必然意味着接口语意的改变，在不改变接口的情况下，其实是无法选择的(试试看，用返回值处理构造函数中的错误)。通过不变式区别出正常和异常状况，还可以更好地提炼接口。

　　对于异常安全的评定，可分为三个级别：基本保证、强保证和不会失败。

　　基本保证：确保出现异常时程序（对象）处于未知但有效的状态。所谓有效，即对象的不变式检查全部通过。
　　强保证：确保操作的事务性，要么成功，程序处于目标状态，要么不发生改变。
　　不会失败：对于大多数函数来说，这是很难保证的。对于C++程序，至少析构函数、释放函数和swap函数要确保不会失败，这是编写异常安全代码的基础。

　　首先从异常情况下资源管理的问题开始.很多人可能都这么干过:

　　不要这么做!这么做只会使你的代码看上去混乱,而且会降低效率,这也是一直以来异常名声不大好的原因之一. 请借助于RAII技术来完成这样的工作:

　　这样的代码简洁、安全而且无损于效率。当你不关心或是无法处理异常时,请不要试图捕获它。并非使用try...catch才能编写异常安全的代码,大部分异常安全的代码都不需要try...catch。我承认，现实世界并非总是如上述的例子那样简单，但是这个例子确实可以代表很多异常安全代码的做法。在这个例子中，boost::scoped_ptr是auto_ptr一个更适合的替代品。

　　现在来考虑这样一个构造函数：

　　假设成员变量m_a和m_b是原始的指针类型，并且和Type内的申明顺序一致。这样的代码是不安全的，它存在资源泄漏问题，构造函数的失败回滚机制无法应对这样的问题。如果new TypeB抛出异常,new TypeA返回的资源是得不到释放机会的.曾经,很多人用这样的方法避免异常:

　　当然,这样的方法确实是能够实现异常安全的代码的,而且其中实现思想将是非常重要的,在如何实现强保证的异常安全代码中会采用这种思想.然而这种做法不够彻底，至少析构函数还是要手动完成的。我们仍然可以借助RAII技术，把这件事做得更为彻底：shared_ptr<TypeA> m_a; shared_ptr<TypeB> m_b;这样,我们就可以轻而易举地写出异常安全的代码:

　　如果你觉得shared_ptr的性能不能满足要求，可以编写一个接口类似scoped_ptr的智能指针类,在析构函数中释放资源即可。如果类设计成不可复制的，也可以直接用scoped_ptr。强烈建议不要把auto_ptr作为数据成员使用,scoped_ptr虽然名字不大好，但是至少很安全而且不会导致混乱。

　　RAII技术并不仅仅用于上述例子中，所有必须成对出现的操作都可以通过这一技术完成而不必try...catch.下面的代码也是常见的：

　　可以这样解决，先提供一个成对操作的辅助类：

　　然后，代码只需这样写：

　　清晰而优雅！继续考察这个例子,假设我们并不需要成对操作, 显然，修改scoped_lock构造函数即可解决问题。然而，往往方法名称和参数也不是那么固定的，怎么办？可以借助这样一个辅助类：

　　好了，借助boost库,我们可以这样来编写代码了：

　　我承认，这样的代码不如前面的简洁和容易理解，但是它更灵活,无论函数名称是什么，都可以拿来结对。我们可以加强对bind的运用，结合占位符和reference_wrapper,就可以处理函数参数、动态绑定变量。所有我们在catch内外的相同工作，交给pair_guard去完成即可。

　　考察前面的几个例子，也许你已经发现了，所谓异常安全的代码，竟然就是如何避免try...catch的代码，这和直觉似乎是违背的。有些时候，事情就是如此违背直觉。异常是无处不在的，当你不需要关心异常或者无法处理异常的时候，就应该避免捕获异常。除非你打算捕获所有异常，否则，请务必把未处理的异常再次抛出。try...catch的方式固然能够写出异常安全的代码，但是那样的代码无论是清晰性和效率都是难以忍受的，而这正是很多人抨击C++异常的理由。在C++的世界，就应该按照C++的法则来行事。

　　如果按照上述的原则行事，能够实现基本保证了吗？诚恳地说，基础设施有了，但技巧上还不够，让我们继续分析不够的部分。

　　对于一个方法常规的执行过程，我们在方法内部可能需要多次修改对象状态，在方法执行的中途，对象是可能处于非法状态的（非法状态 != 未知状态），如果此时发生异常，对象将变得无效。利用前述的手段，在pair_guard的析构中修复对象是可行的，但缺乏效率，代码将变得复杂。最好的办法是......是避免这么作，这么说有点不厚道，但并非毫无道理。当对象处于非法状态时，意味着此时此刻对象不能安全重入、不能共享。现实一点的做法是：

　　a.每一次修改对象，都确保对象处于合法状态
　　b.或者当对象处于非法状态时，所有操作决不会失败。

　　在接下来的强保证的讨论中细述如何做到这两点。

　　强保证是事务性的，这个事务性和数据库的事务性有区别，也有共通性。实现强保证的原则做法是：在可能失败的过程中计算出对象的目标状态，但是不修改对象，在决不失败的过程中，把对象替换到目标状态。考察一个不安全的字符串赋值方法：

　　locked_pool是为了锁定内存页。为了讨论的简单起见，我们假设只有locked_pool构造函数和allocate是可能抛出异常的，那么这段代码连基本保证也没有做到。若allocate失败，则m_data取值将是非法的。参考上面的b条目，我们可以这样修改代码：

　　现在，如果locked_pool失败，对象不发生改变。如果allocate失败，对象是一个空字符串，这既不是初始状态，也不是我们预期的目标状态，但它是一个合法状态。我们阐明了实现基本保证所需要的技巧部分，结合前述的基础设施（RAII的运用），完全可以实现基本保证了...哦,其实还是有一点疏漏，不过，那就留到最后吧。

　　继续，让上面的代码实现强保证：

　　强保证的代码多使用了一个局部变量tmp，先计算出目标状态放在tmp中，然后在安全进入目标状态，这个过程我们并没有损失什么东西（代码清晰性，性能等等）。看上去，实现强保证并不比基本保证困难多少，一般而言，也确实如此。不过，别太自信，举一种典型的很难实现强保证的例子，对于区间操作的强保证：

　　如果某个do_something失败了，range将处于什么状态？这段代码仍然做到了基本保证，但不是强保证的，根据实现强保证的基本原则，我们可以这么做：

　　似乎很简单啊！呵呵，这样的做法并非不可取，只是有时候行不通。因为我们额外付出了性能的代价，而且，这个代价可能很大。无论如何，我们阐述了实现强保证的方法，怎么取舍则由您决定了。

　　接下来讨论最后一种异常安全保证：不会失败。

　　通常，我们并不需要这么强的安全保证，但是我们至少必须保证三类过程不会失败：析构函数，释放类函数，swap。析构和释放函数不会失败，这是RAII技术有效的基石，swap不会失败，是为了“在决不失败的过程中，把对象替换到目标状态”。我们前面的所有讨论都是建立在这三类过程不会失败的基础上的，在这里，弥补了上面的那个疏漏。

　　一般而言，语言内部类型的赋值、取地址等运算是不会发生异常的，上述三类过程逻辑上也是不会发生异常的。内部运算中，除法运算可能抛出异常。但是地址访问错通常是一种错误，而不是异常，我们本应该在前条件检查中就发现的这一点的。所有不会发生异常操作的简单累加，仍然不会导致异常。

　　好了，现在我们可以总结一下编写异常安全代码的几条准则了：

　　1.只在应该使用异常的地方抛出异常
　　2.如果不知道如何处理异常，请不要捕获(截留)异常。
　　3.充分使用RAII，旁路异常。
　　4.努力实现强保证，至少实现基本保证。
　　5.确保析构函数、释放类函数和swap不会失败。

　　另外，还有一些语言细节问题，因为和这个主题有关也一并列出：

　　1.不要这样抛出异常：throw new exception;这将导致内存泄漏。
　　2.自定义类型，应该捕获异常的引用类型：catch(exception& e)或catch(const exception& e)。
　　3.不要使用异常规范，即使是空异常规范。编译器并不保证只抛出异常规范允许的异常，更多内容请参考相关书籍。

CODE:

    .file    "switch.c"
    .version    "01.01"
gcc2_compiled.:
.text
    .align 4
.globl switch_eg
    .type     switch_eg,@function
switch_eg:
    pushl %ebp
    movl %esp,%ebp
    movl 8(%ebp),%edx
    leal -100(%edx),%eax
    cmpl ,%eax
    ja .L9
    jmp *.L10(,%eax,4)
    .p2align 4,,7
.section    .rodata
    .align 4
    .align 4
.L10:
    .long .L4
    .long .L9
    .long .L5
    .long .L6
    .long .L8
    .long .L9
    .long .L8
.text
    .p2align 4,,7
.L4:
    leal (%edx,%edx,2),%eax
    leal (%edx,%eax,4),%edx
    jmp .L3
    .p2align 4,,7
.L5:
    addl ,%edx
.L6:
    addl ,%edx
    jmp .L3
    .p2align 4,,7
.L8:
    imull %edx,%edx
    jmp .L3
    .p2align 4,,7
.L9:
    xorl %edx,%edx
.L3:
    movl %edx,%eax
    movl %ebp,%esp
    popl %ebp
    ret
.Lfe1:
    .size     switch_eg,.Lfe1-switch_eg
    .ident    "GCC: (GNU) 2.95.3 20010315 (release)"在上面的汇编代码中我们可以很清楚的看到switch部分被分配了一个连续的查找表，switch case中不连续的部分也被添加上了相应的条目，switch表的大小不是根据case语句的多少，而是case的最大值的最小值之间的间距。在选择相应 的分支时，会先有一个cmp子句，如果大于查找表的最大值，则跳转到default子句。而其他所有的case语句的耗时都回事O(1)。

相比于if-else结构，switch的效率绝对是要高很多的，但是switch使用查找表的方式决定了case的条件必须是一个连续的常量。而if-else则可以灵活的多。

没想到会遇到这样的问题，

在VC6环境下测试，重点请看红色字体与图片。

#include "stdafx.h"

#include <stdio.h>

typedef struct sData

{

    static const char* text;

    static int  val_a;

    static int  val_b;

} sData, *Self_Ptr;

typedef struct 

{

    char* text;

    int val_a;

    int val_b;

}* Other_Ptr;

const char* sData::text = "this is a test string\0";

int   sData::val_b = 200;

int   sData::val_a = 100;

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

{

    Self_Ptr p_self = (Self_Ptr)&(sData::text);

    Other_Ptr p_other = (Other_Ptr)&(sData::text);

    printf("%d\n", sizeof(sData));                          //----1, static成员不计入sizeof

    printf("val_a: %d-%d\n", p_self->val_a, sData::val_a);  //----val_a: 100-100

    printf("val_b: %d-%d\n", p_self->val_b, sData::val_b);  //----val_b: 200-200

    printf("val_a: %d-%d\n", p_self->val_a, p_other->val_a);//----val_a: 100-200

    printf("val_b: %d-%d\n", p_self->val_b, p_other->val_b);//----val_b: 200-100

    return 0;

}

对POD

struct Data

{

    int a;

    int b[32];

    char c[128];

};

C/C++不能够支持如下的语法：sizeof(Data::a); sizeof(Data::b); sizeof(Data::c[0]), sizeof必须要有存在的对象，才可以进行操作,这个不好

仿照offsetof宏，定义一个SIZEOF宏：#define SIZEOF(s,m) sizeof(((s *)0)->m)

在VC6下可以工作，其他环境不知

#define SIZEOF(s,m) sizeof(((s *)0)->m)

struct Data

{

    int a;

    int  b[32];

    char c[128];

};

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

{

    int z = 0;

    z = SIZEOF(Data, a);    //---- 4

    z = SIZEOF(Data, b);//---- 128

    z = SIZEOF(Data, c);//---- 128

    z = SIZEOF(Data, b[0]);//---- 4

    z = SIZEOF(Data, c[0]);//---- 1

    return 1;

}

将 C++ 函数声明为``extern "C"''（在你的 C++ 代码里做这个声明），然后调用它（在你的 C 或者 C++ 代码里调用）。例如：

// C++ code:

extern "C" void f(int);

void f(int i)

{

     // ...

}

然后，你可以这样使用 f()：

/* C code: */

void f(int);

void cc(int i)

{

    f(i);

   /* ... */

    }

当然，这招只适用于非成员函数。如果你想要在 C 里调用成员函数（包括虚函数），则需要提供一个简单的包装（wrapper）。例如：

// C++ code:

class C

{

   // ...

   virtual double f(int);

};

extern "C" double call_C_f(C* p, int i) // wrapper function

{

   return p->f(i);

}

然后，你就可以这样调用 C::f()：

/* C code: */

double call_C_f(struct C* p, int i);

void ccc(struct C* p, int i)

{

   double d = call_C_f(p,i);

   /* ... */

}

如果你想在 C 里调用重载函数，则必须提供不同名字的包装，这样才能被 C 代码调用。例如：

// C++ code:

void f(int);

void f(double);

extern "C" void f_i(int i) { f(i); }

extern "C" void f_d(double d) { f(d); }

然后，你可以这样使用每个重载的 f()：

/* C code: */

void f_i(int);

void f_d(double);

void cccc(int i,double d)

{

   f_i(i);

   f_d(d);

   /* ... */

}

注意，这些技巧也适用于在 C 里调用 C++ 类库，即使你不能（或者不想）修改 C++ 头文件。

extern "C" 之后,就不能重载函数了,关键还是函数名修饰的问题.

大卫注:
这段时间整理旧资料,看到一些文章,虽然讲的都是些小问题,不大可能用到,但也算是一个知识点,特整理出来与大家共享.与此相关的那篇文章的作者的有些理解是错误的,我写此文,也是纠正为了作者的一些错误认识.当然,如果我的理解有任何错误,也恳请大家批评指正.

C++虽说被B.S.称作一门新语言,但它毕竟与C有着千丝万缕的联系,虽然B.S.一再坚持,但我还是愿意把C++看作是C ++.
我们应该按照C中的convention去使用union,这是我这篇文章要给出的观点.虽然C++使得我们可以扩展一些新的东西进去,但是,我建议你不要那样去做,看完这篇文章之后,我想你大概也是这么想的.

C由于没有类的概念,所有类型其实都可以看作是基本类型的组合,因此在union中包含struct也就是一件很自然的事情了,到了C++之后,既然普遍认为C++中的struct与class基本等价,那么union中是否可以有类成员呢?先来看看如下的代码:

struct TestUnion
{
    TestUnion() {}
};

typedef union
{
    TestUnion obj;
} UT;

int main (void)
{
    return 0;
}

编译该程序,我们将被告知:
error C2620: union '__unnamed' : member 'obj' has user-defined constructor or non-trivial default constructor
而如果去掉那个什么也没干的构造函数,则一切OK.

为什么编译器不允许我们的union成员有构造函数呢?我无法找到关于这个问题的比较权威的解释,对这个问题,我的解释是:
如果C++标准允许我们的union有构造函数,那么,在进行空间分配的时候要不要执行这个构造函数呢?如果答案是yes,那么如果TestUnion的构造函数中包含了一些内存分配操作,或者其它对整个application状态的修改,那么,如果我今后要用到obj的话,事情可能还比较合理,但是如果我根本就不使用obj这个成员呢?由于obj的引入造成的对系统状态的修改显然是不合理的;反之,如果答案是no,那么一旦我们今后选中了obj来进行操作,则所有信息都没有初始化(如果是普通的struct,没什么问题,但是,如果有虚函数呢?).更进一步,假设现在我们的union不是只有一个TestUnion obj,还有一个TestUnion2 obj2,二者均有构造函数,并且都在构造函数中执行了一些内存分配的工作(甚至干了很多其它事情),那么,如果先构造obj,后构造obj2,则执行的结果几乎可以肯定会造成内存的泄漏.
鉴于以上诸多麻烦(可能还有更多麻烦),在构造union时,编译器只负责分配空间,而不负责去执行附加的初始化工作,为了简化工作,只要我们提供了构造函数,就会收到上面的error.
同理,除了不能加构造函数,析构函数/拷贝构造函数/赋值运算符也是不可以加.

此外,如果我们的类中包含了任何virtual函数,编译时,我们将收到如下的错误信息:
error C2621: union '__unnamed' : member 'obj' has copy constructor

所以,打消在union中包含有构造函数/析构函数/拷贝构造函数/赋值运算符/虚函数的类成员变量的念头,老老实实用你的C风格struct吧!
不过,定义普通的成员函数是OK的,因为这不会使得class与C风格的struct有任何本质区别,你完全可以将这样的class理解为一个C风格的struct + n个全局函数.

现在,再看看在类中包含内部union时会有什么不同.看看下面的程序,并请注意阅读程序提示:

class TestUnion
{
    union DataUnion
    {
        DataUnion(const char*);
        DataUnion(long);
        const char* ch_;
        long       l_;
    } data_;

public:
    TestUnion(const char* ch);
    TestUnion(long l);
};

TestUnion::TestUnion(const char* ch) : data_(ch) // if you want to use initialzing list to initiate a nested-union member, the union must not be anonymous and must have a constructor.
{
}

TestUnion::TestUnion(long l) : data_(l)
{
}

TestUnion::DataUnion::DataUnion(const char* ch) : ch_(ch)
{
}

TestUnion::DataUnion::DataUnion(long l) : l_(l)
{
}

int main (void)
{
    return 0;
}

正如上面程序所示,C++中的union也可以包含构造函数,但是,这虽然被语言所支持,但实在是一种不佳的编程习惯,因此,我不打算对上面的程序进行过多的说明.我更推荐如下的编程风格:

class TestUnion
{
    union DataUnion
    {
        const char* ch_;
        long       l_;
    } data_;
   
public:
    TestUnion(const char* ch);
    TestUnion(long l);
};

TestUnion::TestUnion(const char* ch)
{
    data_.ch_ = ch;
}

TestUnion::TestUnion(long l)
{
    data_.l_ = l;
}

int main (void)
{
    return 0;
}

它完全是C风格的.

所以,接受这个结论吧:
请按照C中的convention去使用union,尽量不要尝试使用任何C++附加特性.

# "比较权威的解释", B.S权威不？可惜你不看他的书。

以下摘自《 the c++ programming language 3rd 》，对为什么union不支持构造函数和析构函数，推荐怎么使用unions都有说明。

10.4.12 Unions [class.union]
A named union is defined as a struct, where every member has the same address (see §C.8.2). A
union can have member functions but not static members.
In general, a compiler cannot know what member of a union is used; that is, the type of the
object stored in a union is unknown. Consequently, a union may not have members with constructors
or destructors. It wouldn’t be possible to protect that object against corruption or to guarantee
that the right destructor is called when the union goes out of scope.
Unions are best used in lowlevel
code, or as part of the implementation of classes that keep
track of what is stored in the union (see §10.6[20]).

其实正如在vckbase/c++论坛上我对你说的，想想union的用途就可以了。union的出现是为了解决一组不定类型数据的空间紧张问题，它是为省空间用的，不是为了封装数据和方法。所以我觉得大卫兄太过于刨根究底了，而忽略了C++的实用性(实用性是C/C++的首要设计思想)

2004-11-12 10:18 | 一笑

# re: (大卫的阅读笔记)C++中使用union的几点思考

谢谢笑兄给出的CPL中的相关论述.我现在主要关注的内容并非C++(虽然C++是我最喜欢的语言),我在blog上发布这些文章也只是希望谈一下自己对于某些语言特性或新技术的认识,以期对后来者有些许帮助,同时,也希望在与大家的交流中提高自己.
^_^,也许我真的有点刨根究底,不过笑兄的关于"union是为省空间用的"的观点我不认同,虽然,我也看到过类似的说法,但是,union怎么可能节省空间呢?如:
union uT
{
int i;
char c;
};
当他被作为char使用时,明明浪费了空间.
只是从另一角度出发:把它当成一种特殊的struct,与struct相比时才可以勉强说是节省了空间.
我认为union的引入,更多地是提供了一种解决多种型别共同使用同一空间(这与节省空间是两回事)的机制,借助这种机制,我们可以提供更丰富的语言表现力.
为此,我决定再写一篇文章,谈一些比较有意思/有意义的union的使用,请关注 & 批评指正.

2004-11-13 05:11 | Bill David

# 对union的进一步认识与一些深层应用[TrackBack]

Ping Back来自：blog.csdn.net
Bill David引用了该文章,地址:http://blog.csdn.net/billdavid/archive/2004/11/26/195006.aspx

2004-11-26 18:58 | Bill David

# re: (大卫的阅读笔记)C++中使用union的几点思考

呵呵，仁者见仁，智者见智。
但是union的确应该是节省空间使用的。当时的初衷是这样的。但是后来就不一定了。3ks 二位。

2005-04-19 17:38 | 漫天飞舞

# 今日经论坛匿名大侠指点，union还有一个重要的特性

union不支持继承。

特记录于此。

2005-04-19 17:59 | Bill David

# re: union不支持继承。

我突然觉得如果union设计为可继承的也未尝不可。
union base
{
    int mem1;
    char mem2;
};
这个假设被原实现者设计好了，突然，某天我想在base的基础上添加一些特性，于是我写
union derive : base
{
    short mem 3;
};
或许可能实际意义不大吧！但，如果这么说，我reinterpret_cast成员mem1呢？union的实际意义又有多大呢？

不知道你怎么看？

2006-05-16 13:35 | 清风雨

# re: union的几点思考

又看了你的另一篇union的，可能我比较懒惰的缘故，我只得到一个结论： union仅仅只是为了方便。

2006-05-16 13:49 | 清风雨

# re: (大卫的阅读笔记)C++中使用union的几点思考

这都是些什么?

2006-05-18 21:35 | 一二三

# re: (大卫的阅读笔记)C++中使用union的几点思考

看不懂

2006-05-18 21:36 | 一二三

# re: (大卫的阅读笔记)C++中使用union的几点思考

union
{
    struct
           {
                string name;
           }info;
    int  age;
}information;

上面的语句可能出错,has copy constructor.   难道只有把string -->char *吗??

2006-07-07 15:38 | Tmin

# re: (大卫的阅读笔记)C++中使用union的几点思考

看了文章和回帖，我非常同意一笑兄的看法。我觉得作者没有完全理解“节省空间”的指的是如何节省，例如我们获取一些信息时，需要把信息数据填充到一个结构中，但是我们需要的信息的数据的类型会根据情况不同而不同，如果我们为了通用的话，可能就需要为所有可能出现的类型都预留相应的空间来存储，但是每次只能使用其中一个有效。其他预留无效。这显然是浪费空间的。所以union使得不同类型数据存放在内存的同一个位置，当然这个空间的大小是能容纳所有类型的数据的。因为unicon的数据类型是运行时决定的，事先并不知道，所以为union做一个构造函数是没有意义的。

2006-10-17 11:48 | hoodlum

# re: (大卫的阅读笔记)C++中使用union的几点思考

刚才回的仓促，可能有论述不是很恰当。但是看了作者的另一篇文章里面引用的英文，论述的也和我本来的想法是一致的。也就是说，可以使用union.memberData来访问成员，但是应该注意的是，使用时只有其中一个成员才是有意义的。union占用的空间大小是所有成员数据大小的最小公倍数。（因此，转为托管代码中就可以使用一个能够容纳union大小的数据类型来代替，或者用通用的字节数组）

例如下面的例子（来自Windows API）：
union
{    
   DWORD dwOemId;    
   struct {
                 WORD wProcessorArchitecture; 
                 WORD wReserved; 
              };
  };

它通常占用4个字节，因此可以使用托管代码中的Int32来代替。
其中dwOemId是为了向前兼容某些系统版本，当前已经弃用。这样，一个程序对API的调用可以在不同版本的系统中运转良好，处理各自自己需要的数据。

BOOL foo(int index);

BOOL bSuccess = TRUE;

for(int i = 0; i < value; ++i)

{

    bSuccess = (bSuccess && foo(i));

}

unsigned char a=2, b=1;
也会得到同样的结果。
答案是：无论a+b还是a-b，不超过int范围的数值运算表达式最终都会以一个int类型作为结果类型

一个文件中
    const int a = 1;
另一个文件中
    extern const int a;
    cout << a << endl;
类似的代码在C中OK，但在C++中没能Link通过。

改为
一个文件中
extern "C" {
    const int a = 1;
}
另一个文件中
extern "C" {
    extern const int a;
    cout << a << endl;
}
在C++中也没能Link通过。

[全局变量]给我的解答是：

C and C++ const Differences
When you declare a variable as const in a C source code file, you do so as:

const int i = 2;

You can then use this variable in another module as follows:

extern const int i;

But to get the same behavior in C++, you must declare your const variable as:

extern const int i = 2;

If you wish to declare an extern variable in a C++ source code file for use in a C source code file, use:

extern "C" const int x=10;

to prevent name mangling by the C++ compiler.

于是我改为
一个文件中
    extern "C" const int a = 1;
另一个文件中
    extern "C" const int a;
    cout << a << endl;
在C++中OK

改为
一个文件中
extern "C" {
    extern "C" const int a = 1;
}
另一个文件中
extern "C" {
    extern "C" const int a;
}
在C++中也OK

看来 extern "C" 和 extern "C" {} 还是有区别的^_^
----------------------------------------
const在C和C++中的其他区别不说了，比如const在C++偏向于“常量”，而在C中偏向于“只读”
简单的说，在C++中，a 是一个编译期常量，所以不进obj文件，用extern无效。
在这种情况下，C++都是建议把他放到头文件中去的。

posted on 2006-10-31 17:23 周星星 阅读(4342) 评论(2) 编辑 收藏

评论

# re: const在C和C++中的一个区别 2006-11-10 21:41 路人甲

记得c++编程思想第1卷中好象讲过这个问题,c++中const是内连接的.

# re: const在C和C++中的一个区别 2007-11-23 16:34 空见

//***a.cpp***
#include <iostream>
extern const int i;
void main ()
{
  std::cout << i;
}
//***b.cpp***
extern const int i = 10;
执行结果：
10
不关extern "C"的事情，正如路人甲所说，是const的内连接特性造成的

虽然平时在程序开发时较少使用union,虽然当初学C语言时,union一章被老师略过没有介绍,虽然,自认为自己对union的认识已经足够,但是,在写完上一篇文章<(大卫的阅读笔记)C++中使用union的几点思考>之后,网上的讨论驱使我对这一基本的语言特性又投入了一些精力去关注,并写成了此文.

下面以MSDN中关于union的概述作为开头,这好像有些无聊,不过,有时候看specification的东西可以给我们很多提示,当我们从应用的角度去关注一样东西的时候,很多更深层次的考虑被我们忽略了.所以,看下去,里面有些东西可能正是你忽略了的.

union
union [tag] { member-list } [declarators];

[union] tag declarators;

The union keyword declares a union type and/or a variable of a union type.

A union is a user-defined data type that can hold values of different types at different times. It is similar to a structure
except that all of its members start at the same location in memory. A union variable can contain only one of its members at
a time. The size of the union is at least the size of the largest member(大卫注:我想不出来大于的情况).

For related information, see class, struct, and Anonymous Union.

Declaring a Union

Begin the declaration of a union with the union keyword, and enclose the member list in curly braces:

union UNKNOWN    // Declare union type
{
   char   ch;
   int    i;
   long   l;
   float  f;
   double d;
} var1;          // Optional declaration of union variable
Using a Union

A C++ union is a limited form of the class type. It can contain access specifiers (public, protected, private), member data,
and member functions, including constructors and destructors. It cannot contain virtual functions or static data members. It
cannot be used as a base class, nor can it have base classes. Default access of members in a union is public.

A C union type can contain only data members.

In C, you must use the union keyword to declare a union variable. In C++, the union keyword is unnecessary:

Example 1

union UNKNOWN var2;   // C declaration of a union variable
UNKNOWN var3;         // C++ declaration of a union variable
Example 2

A variable of a union type can hold one value of any type declared in the union. Use the member-selection operator (.) to access a member of a union:

var1.i = 6;           // Use variable as integer
var2.d = 5.327;       // Use variable as double

为了避免对上述文字有稍许的歪曲,我故意没有翻译它,但在此对其进行一些归纳:
1.union是一种特殊的struct/class,是一种可用于容纳多种类型的类型,但与struct/class不同的是,所有的成员变量共享同一存储空间(最大的那一个成员类型的大小),这使得它具有多变的特性,可以在不同成员中任意切换,而无需借助强制类型转换,但这也使得你不能把它当作一个成员变量进行修改而不影响到另一成员变量;
2.union也可以有构造/析构函数,也可以包含访问标识符,但不能包含虚函数或静态成员变量/方法.

关于使用union时需要注意的一些问题,可以参考我的前一篇文章:<(大卫的阅读笔记)C++中使用union的几点思考>.
下面谈谈一些比较有意思并且有意义的union的应用.
1.in_addr

struct in_addr {
  union {
          struct { u_char s_b1,s_b2,s_b3,s_b4; }   S_un_b;
          struct { u_short s_w1,s_w2; }            S_un_w;
          u_long                                   S_addr;
  } S_un;
};

对于上面的struct,写过socket应用的人,肯定都用过它.不知你注意过没有,它包含了一个很有趣的union,该union的各成员具有相同的大小,分别代表同一信息的不同表现形式.你在进行程序设计的时候也可以利用这一特性来提供同一信息的不同表现形式,不过要注意,在进行跨平台应用时,字节顺序的影响可能给你造成一些不必要的麻烦.

2.匿名union
匿名union是没有名称和声明列表的union,这跟'__unnamed' union不是一回事,它的声明形式如下:
union { member-list } ;

匿名union仅仅通知编译器它的成员变量共享一个地址,而变量本身是直接引用的,不使用通常的点号运算符语法.也正因此,匿名union与同一程序块内的其它变量具有相同的作用域级别,需注意命名冲突.
请看下面的例子:

#include <iostream.h>

struct DataForm
{
    enum DataType { CharData = 1, IntData, StringData };
    DataType type;

    // Declare an anonymous union.
    union
    {
        char  chCharMem;
        char *szStrMem;
        int   iIntMem;
    };
    void print();
};

void DataForm::print()
{
   // Based on the type of the data, print the
    // appropriate data type.
    switch( type )
    {
    case CharData:
        cout << chCharMem;
        break;
    case IntData:
        cout << szStrMem;
        break;
    case StringData:
        cout << iIntMem;
        break;
    }
}

此外,匿名union还具有以下约束:
1).因为匿名联合不使用点运算符,所以包含在匿名联合内的元素必须是数据,不允许有成员函数,也不能包含私有或受保护的成员;
2).全局匿名联合必须是静态(static)的，否则就必须放在匿名名字空间中.

附注:
对匿名union的概念,你或许有些陌生,但对于Windows应用的开发人员,有一个经常用到的结构中就包含了匿名union,它就是VARIANT,也许你没有注意它罢了:

typedef struct FARSTRUCT tagVARIANT VARIANT;
typedef struct FARSTRUCT tagVARIANT VARIANTARG;

typedef struct tagVARIANT  {
   VARTYPE vt;
   unsigned short wReserved1;
   unsigned short wReserved2;
   unsigned short wReserved3;
   union {
      Byte                    bVal;                 // VT_UI1.
      Short                   iVal;                 // VT_I2.
      long                    lVal;                 // VT_I4.
      float                   fltVal;               // VT_R4.
      // ...
   };
};

3.利用union进行类型转换
前面已经说过,union具有多变的特性,可以在不同成员中任意切换,而无需借助强制类型转换,下面举例说明这一点(其实1已经很好地说明了这一点):

#include <iostream>
using namespace std;

struct DATA
{
    char c1;
    char c2;
};

int main()
{
    union { 
        int i; 
        DATA data;
    } _ut;
   
    _ut.i = 0x6162;

    cout << "_ut.data.c1 = " << _ut.data.c1 << endl
        << "_ut.data.c2 = " << _ut.data.c2 << endl;
   
    return 0;
}

需要提醒你的是,数据类型的转换,并非union的专长,只是一个可资利用的特性而已.因为,采用union进行类型间转换极易受平台影响,如上面的程序采用Intel x86 + Windows 2000 + VC6时输出为:
_ut.data.c1 = b
_ut.data.c2 = a
(注:因为Intel CPU的架构是Little Endian)
而在Sun的Sparc上,你得到的结果却是:
_ut.data.c1 = 
_ut.data.c2 =
(注:因为采用Big Endian时,前两个字节为0x0000)

而即便是在同一平台上,在integer类型与real类型间进行转换时也不要采用union,否则,你会得到令你莫名其妙的结论(这是由于CPU对real类型的处理方式引起的,该方式在各平台上有极大区别,同时,根据C++ Standard,这种作法会引起"undefined behavior").

关于利用引用进行类型转换,可参考<引用在强制类型转化中的应用>.

# re: 对union的进一步认识与一些深层应用

“我想不出来大于的情况”
--- 还有字节对齐的情况，和struct一样

匿名union我经常使用，但我不知道它叫“匿名union”，而且还可以放在外边用，我去试试看，谢谢！

2004-11-26 22:07 | 周星星

# re: 对union的进一步认识与一些深层应用

你的文章写的很好,总结得不错

2005-05-05 13:34 | peak

# re: 对union的进一步认识与一些深层应用

union实际上是一个二进制容器，所以当程序中从不同的角度来解释这个二进制数据的时候非常容易受各种实现细节的影响，尤其是涉及到这些二进制数据在不同平台和编译器之间交换的时候。

2005-10-29 00:51 | youngs

# re: 对union的进一步认识与一些深层应用

多谢文章。请教问题：union中的成员类型只能是基本的类型，不能使自己定义的类结构么？ 比如说 CMyLine m_Ln?

2007-12-13 11:52 | cc

# re: 对union的进一步认识与一些深层应用

union既然可以包含struct，自然也是可以包含从class的，但是存在诸多限制，同时，很难想象你的应用需要在union中包含一个复杂class，如CString或STL的string。

2008-03-03 15:44 | 大卫的思维空间

CRITICAL_SECTION m_CS;

我写了一个函数放到了一个abc.h文件中，在mfc项目的stdafx.h中添加了包含abc.h   ,则   出现链接错误LNK2005
如不放到stdafx.h中，而直接在使用这个函数的cpp文件里包含这个abc.h   就不会有错 20 回复次数：8

第1个回答
你这个abc.h有函数实现么?
有没有定义全局变量?

第2个回答
谢谢帮助，abc.h
中有函数实现，但没有全局变量

第3个回答
#ifndef   _ABCFUNC
#define   _ABCFUNC
在此处添加函数定义
#endif

第4个回答
使用inline.

第5个回答
#ifndef       _ABCFUNC
#define       _ABCFUNC
在此处添加函数定义
#endif
已经加上了   用的是   #pragma   once  
加入   使用inline.   确实解决了问题   还请   xyzhaopeng     讲讲为什么  

第6个回答
编译器认为你对函数没有作声明，所以会   出错，加上inline就说明你的函数是个内联函数，这样编译器就会认为你是在声明时加的函数体。

第7个回答
编译器是编译每个cpp文件,你在abc.h里面写了函数的实现,afx.h里面include了abc.h,
而有很多gecpp文件include了afx.h,也就是很多个cpp文件里面有这个函数的实现,
在链接器链接时就会发现有多个同名函数,所以会报错.
如果最终只有一个cpp文件include了abc.h则不会出错,或者在abc.h中将函数申明为inline.

第8个回答
谢谢各位的热心帮助  
我是在学习wtl
wtl没有cpp文件，所有实现都写在了h文件里面
却没有这种问题呢？

#####################################################################################################

#####################################################################################################

VC的LNK2005错误，用于避免重复包含的宏为什么无效？

头文件设置如下：
#ifndef _MY_HPP_
#define _MY_HPP_
/*
内容：
函数A
函数B
……
*/
#endif
可当我在同一工程的多个cpp文件（例如文件1和文件2）里#include此头文件时，编译倒能正常通过，可是连接时却出现了报错。大致意思是说：“在文件1.obj中的函数A已经在文件2中定义。”而且是头文件中有多少个函数就会出现多少条这样的连接错误提示。
既然已经设置了保护宏，为什么还不管用呢？急问，拜托了，叩谢。

作者： 125.33.0.*

2008-5-6 20:08 回复此发言

2
回复：VC的LNK2005错误，用于避免重复包含的宏为什么无效？

如果把被提示的函数设置为inline就不会报错了，可我总不能把所有函数都声明成inline吧？该怎么办啊？

作者： 125.33.0.*

2008-5-6 20:54 回复此发言

3
回复：VC的LNK2005错误，用于避免重复包含的宏为什么无效？

"如果把被提示的函数设置为inline就不会报错了"
说明你在头文件里面有实现。。
这样多个包含这个头文件的cpp文件都有实现
link的时候就有多分。
头文件一般是申明， 实现应该放到某一个cpp文件里面
这样link的时候就只有一份在“某一个cpp文件”

作者： 125.34.177.*

2008-5-6 23:14 回复此发言

4
回复：VC的LNK2005错误，用于避免重复包含的宏为什么无效？

终于有回复了，感激涕零ing……T_T
Sorry……我那个头文件说穿了就是个为了以后公用而写的“函数库”，是独立于当前工程之外的，故而头文件里的这些函数也不是任何一个类的成员函数。
况且，这个头文件在Dev-Cpp里即使包含了多次也没有任何错误的啊。
还有，如果真的要把这些函数的实现挪到cpp里，那岂不还是得把这个cpp文件同样在包含此头文件的位置上照旧#include一遍，跟直接#include这个头文件还有什么不同呢？
OK，不管怎么着，先谢谢3楼的老大了：）

作者： 125.33.10.*

2008-5-7 00:18 回复此发言

5
回复：VC的LNK2005错误，用于避免重复包含的宏为什么无效？

晕
是这样写
common.h 当中声明
如
#ifudef
....
void foo();
#endif
common.cpp 当中写实现
#include"common.h"
void foo()
{
....
}
然后调用的文件只需要包含头文件就行了
#include"common"
int call()
{
foo();
}
include的意思就是把整个文件的类容copy过来。

作者： 求是的梦

2008-5-7 01:05 回复此发言

6
回复：VC的LNK2005错误，用于避免重复包含的宏为什么无效？

刚刚在Dev-Cpp里试了一下3、5楼的双文件法，结果成功通过了连接，待会去VC里试试看-_-
可是……可是话说回来，难道写有函数定义的头文件就真的“永远”不能在同一个工程中的不同文件里重复#include了吗？都需要另建一个c或cpp文件来做写函数定义体才能连接成功的吗？
——该不会我这么久以来所坚信的“在头文件里设置了重复包含保护宏之后就可以随意#include了”的观点一直就是错的吧？天！无论如何，先谢谢二位提点，我这就去测验一遍看看……

作者： 125.33.10.*

2008-5-7 01:34 回复此发言

7
回复：VC的LNK2005错误，用于避免重复包含的宏为什么无效？

还是不对呀，按照5楼的方式编写2个文件：
//头文件
#ifndef MY_H
#define MY_H
/*
函数声明……
*/
#endif
//实现文件
#include <同名头文件>
/*
函数定义……
*/
连接时LNK2005倒是消失了，可又出现了新的错误：
error LNK2001: unresolved symbol "函数A"(...)
error LNK2001: unresolved symbol "函数B"(...)
……
俨然一副“当前工程中找不到函数定义”的样子，可我如果把实现文件针对添加到工程里的话，跟我的最初“只#include头文件、不增加工程文件数”的期望可就完全背道而驰了啊。
★★★★★★★★★★
简而言之：怎么才能使我的头文件像自带的头文件（如<iostream>、<string>或<stdio.h>）一样可以随处#include呢？
★★★★★★★★★★

作者： 125.33.19.*

2008-5-7 20:06 回复此发言

8
回复：VC的LNK2005错误，用于避免重复包含的宏为什么无效？

大家一般是怎么写这种dú-lì的通用式头文件的呢？
只用同一个头文件来同时包含函数的声明和定义、并在同一工程中多次#include，究竟可不可行？能不能实现呢？

作者： 125.33.1.*

2008-5-8 00:35 回复此发言

9
或者说是暂时解决

呼~非得把所有函数都设置为static之后才能随处#include……-_-

作者： 问题解决啦

2008-5-9 03:14 回复此发言

#include <stdio.h>
#include <stdlib.h>
enum{
    STRUCT_S1,
    STRUCT_S2
};
struct base{
    const int type;
};
struct s1{
    const int type;//必须位于第一个。
    int abc;
    int def;
};
struct s2{
    const int type;//必须位于第一个。
    long jsk;
    char abcde[10];
};
int main()
{
    void * a[10]={0};
    struct s1 b={STRUCT_S1, 1, 2};
    struct s2 c={STRUCT_S2, 111, "123"};
    a[0] = &b;
    a[1] = &c;
    int i;
    for(i=0; i<10; i++)
    {
        struct base * base;
        if(base = a[i])
        {
            switch(base->type){
                case STRUCT_S1:
                    {
                        struct s1 *p = a[i];
                        printf("%d %d\n", p->abc, p->def);
                    }
                    break;
                case STRUCT_S2:
                    {
                        struct s2 *p = a[i];
                        printf("%ld %s\n", p->jsk, p->abcde);
                    }
                    break;
            }
        }
    }
    return 0;
}

我以前写线程时要么老老实实照着声明写,要么使用C++类的静态成员函数来作为回调函数,经常会因为线程代码而破坏封装.之前虽然知道类成员函数的展开形式，但从没想过利用过它，昨天看深入ATL时无意中学会了这一招:)

类成员方法是一个比较特殊的函数，它在编译时会被转化成普通函数，比如有TMyClass类:
class TMyClass{
    void Func();
};

这个TMyClass::Func最终会转化成 void Func(TMyClass *this); 也就是说在原第一个参数前插入指向对象本身的this指针。

我们可以利用这个特性写一个非静态类成员方法来直接作为线程回调函数，先看_beginthread函数的定义:
unsigned long _RTLENTRY _EXPFUNC _beginthread (void (_USERENTRY *__start)(void *),unsigned __stksize, void *__arg);
其中的第一个参数就是作为线程执行主体的回调函数。它的原型是:void Func(void *)，这个void*参数是作为自定义数据传入的。对比一下上面所说的TMyClass::Func的最终形式，它正好可以符合这里的要求。

现在做个实验:
#include <stdio.h>
#include <process.h>

class TMyClass{
    int m_nCount;
    int m_nId;
public:
    TMyClass(int nId,int nCount)
        :m_nId(nId),m_nCount(nCount)
    {
    }

    void _USERENTRY ThreadProc()            // 类成员方法
    {
        for(int i=0; i<m_nCount; i++)       // 根据m_nCount成员打印一排数字
        {
            printf("Class%d : %d\n",m_nId,i);
        }
    }
};

int main(int argc, char* argv[])
{
    union {                                // 联合类，用于转换类成员方法指针到普通函数指针（试过编译器不允许在这两种函数之间强制转换），不知道有没有更好的方法。
        void (_USERENTRY *ThreadProc)(void *);
        void (_USERENTRY TMyClass::*MemberProc)();
    } Proc;                                // 尽管联合里的两种函数类型现在看起来有很大不同，但它们的最终形式是相同的。

    TMyClass MyClass1(1,10),MyClass2(2,5); // 产生两个TMyClass对象

    Proc.MemberProc = &TMyClass::ThreadProc;   // 转换，Proc.ThreadProc就是对应的普通函数指针了

    _beginthread(Proc.ThreadProc,4096,&MyClass1);   // 开始线程，这里的Proc.ThreadProc实际上是TMyClass::ThreadProc, 它要的this指针是我们给的&MyClass1。
    _beginthread(Proc.ThreadProc,4096,&MyClass2);
    system("pause");
    return 0;
}

运行！神奇吧？:-)

其实不止线程回调函数，其实只要是形如Func(void*,...)的回调函数都可以用这种方法直接使用类成员方法。(前提是第一个void*是自定义数据，也就是说它不能有其它功能)。

当然指想成员函数的指针，这里面的确有段C++设计的问题，C++的成员函数地址通过对象外去引用不能直接通过“&对象.方法”的方式来引用，这个在C++标准里面是没有的，很多人到这里就绝望了，可间接引用呢？而且用很优雅的方式来引用呢？

好了，我也不绕圈子了，给出我的代码，一个简单的 “成员模版函数指针” 的实现，看看C++是如何优雅的实现委托的，真的非常非常的优雅，由于完全自己摸索出来的，真是感慨万千啊。

#include "stdafx.h"

#include <iostream>

using namespace std;

template<typename T>
class A
{
private:
   typedef int (T::*delegateFun)(int);
   T * _This;
   delegateFun _deleGate;

public:   

//This被代理的对象, delegateFun被代理的方法
 
A(T * This, int (T::*delegateFun)(int))
{
       _This = This;
       _deleGate = delegateFun;
}

    //c被代理的参数
int execue(int c)
{
      return (_This->*_deleGate)(c);
}

};

class B
{
public:
int FunA(int a) {return a + 10;}
int FunB(int a) {return a - 10;}
B()
{

}
};

int _tmain(int argc, _TCHAR* argv[])
{

B *objB = new B();

A<B>  delegateObj1(objB, (&B::FunA));
A<B>  delegateObj2(objB, (&B::FunB));

cout << delegateObj1.execue(10) <<endl;
cout << delegateObj2.execue(20) <<endl;

return 0;

}

看完了感觉如何？以后想要设计一个callback回调函数是否明朗了许多？
再也不需要强行搞个static约束方法，那么恶心的东西了吧

# re: 模版函数指针，C++委托的实现－原创  回复  更多评论   

sigslot

2008-09-29 14:05 | 万连文

# re: 模版函数指针，C++委托的实现－原创[未登录]  回复  更多评论   

template<typename T>
int funA(T * This, int (T::*delegateFun)(int), int c)
{
return (This->*delegateFun)(c);
}
可以算做委托调用的基本原理，还需要保存This和delegateFun的值才能称之为委托。

2008-09-29 14:15 | noname

# re: 模版函数指针，C++委托的实现－原创  回复  更多评论   

做了一点点调整，这个应该就是了

2008-09-29 16:06 | 李侃

# re: 模版函数指针，C++委托的实现－原创[未登录]  回复  更多评论   

A<B> delegateObj1(objB, (&B::FunA));
在这里类A必须了解B的类型，而委托存在的意义在于委托类与被委托的对象之间的无关性，可以参照网上一篇关于fastdelegate的文章。

2008-09-29 22:24 | noname

# re: 模版函数指针，C++委托的实现－原创  回复  更多评论   

哈哈～楼主创造力不错！
我也干个类似的事，不过，比楼主还是再"过分"一些～:-P
楼上说得有道理，模板类的解耦是不完全的（虽然一般已经够用），使得A<B>类只能存放B的成员函数指针，A<C>类只能存放C的成员函数指针。
换一下思路，能否在一个对象里边托管多个属于不同的类的成员函数指针？

2008-09-29 23:03 | 踏雪赤兔

# re: 模版函数指针，C++委托的实现－原创  回复  更多评论   

fastdelegate 还可以，去研究一把

2008-09-30 11:45 | 李侃

# re: 模版函数指针，C++委托的实现－原创[未登录]  回复  更多评论   

非常不错！
强大的消息映射、状态机事件映射都要靠这个才能完美的解决成员函数的问题。

2008-09-30 12:46 | cppexplore

# re: 模版函数指针，C++委托的实现－原创  回复  更多评论   

A<B> delegateObj1(objB, (&B::FunA));
在这里类A必须了解B的类型，而委托存在的意义在于委托类与被委托的对象之间的无关性
-----------------------
这才是关键

2008-10-06 11:33 | adie

# re: 模版函数指针，C++委托的实现－原创  回复  更多评论   

boost中bind这样来做：
class button
{
public:

boost::function<void> onClick;
};

class player
{
public:

void play();
void stop();
};

button playButton, stopButton;
player thePlayer;

void connect()
{
playButton.onClick = boost::bind(&player::play, &thePlayer);
stopButton.onClick = boost::bind(&player::stop, &thePlayer);
}

2008-10-06 16:20 | Wang Feng

# re: 模版函数指针，C++委托的实现－原创  回复  更多评论   

boost是很好，可有些庞大，目前并不打算使用
我已经加入了fastdelegate，这个短小精悍，足以解决我的问题了。

2008-10-06 22:14 | 李侃

# re: 模版函数指针，C++委托的实现－原创  回复  更多评论   

听说BOOST明年加入C++标准了!要慢慢去了解下!

　　保留异常来源信息

　　在C++中，无论何时在处理程序内捕获一个异常，关于该异常来源的信息都是不为人知的。异常的具体来源可以提供许多更好地处理该异常的重要信息，或者提供一些可以附加到错误日志的信息，以便以后进行分析。

　　为了解决这一问题，可以在抛出异常语句期间，在异常对象的构造函数中生成一个堆栈跟踪。ExceptionTracer是示范这种行为的一个类。

　　清单 1. 在异常对象构造函数中生成一个堆栈跟踪

　　// Sample Program:

　　// Compiler: gcc 3.2.3 20030502

　　// Linux: Red Hat

　　#include

　　#include

　　#include

　　#include

　　using namespace std;

　　/////////////////////////////////////////////

　　class ExceptionTracer

　　{

　　public:

　　ExceptionTracer()

　　{

　　void * array[25];

　　int nSize = backtrace(array, 25);

　　char ** symbols = backtrace_symbols(array, nSize);

　　for (int i = 0; i < nSize; i++)

　　{

　　cout << symbols[i] << endl;

　　}

　　free(symbols);

　　}

　　};

　　管理信号

　　每当进程执行一个令人讨厌的动作，以致于 Linux? 内核发出一个信号时，该信号都必须被处理。信号处理程序通常会释放一些重要资源并终止应用程序。在这种情况下，堆栈上的所有对象实例都处于未破坏状态。另一方面，如果这些信号被转换成C++ 异常，那么您可以优雅地调用其构造函数，并安排多层 catch 块，以便更好地处理这些信号。

　　清单 2 中定义的 SignalExceptionClass，提供了表示内核可能发出信号的 C++ 异常的抽象。SignalTranslator 是一个基于 SignalExceptionClass 的模板类，它通常用来实现到 C++ 异常的转换。在任何瞬间，只能有一个信号处理程序处理一个活动进程的一个信号。因此，SignalTranslator 采用了 singleton 设计模式。整体概念通过用于 SIGSEGV 的 SegmentationFault 类和用于 SIGFPE 的FloatingPointException 类得到了展示。

　　清单 2. 将信号转换成异常

　　template class SignalTranslator

　　{

　　private:

　　class SingleTonTranslator

　　{

　　public:

　　SingleTonTranslator()

　　{

　　signal(SignalExceptionClass::GetSignalNumber(),

　　SignalHandler);

　　}

　　static void SignalHandler(int)

　　{

　　throw SignalExceptionClass();

　　}

　　};

　　public:

　　SignalTranslator()

　　{

　　static SingleTonTranslator s_objTranslator;

　　}

　　};

　　// An example for SIGSEGV

　　class SegmentationFault : public ExceptionTracer, public

　　exception

　　{

　　public:

　　static int GetSignalNumber() {return SIGSEGV;}

　　};

　　SignalTranslator

　　g_objSegmentationFaultTranslator;

　　// An example for SIGFPE

　　class FloatingPointException : public ExceptionTracer, public

　　exception

　　{

　　public:

　　static int GetSignalNumber() {return SIGFPE;}

　　};

　　SignalTranslator

　　g_objFloatingPointExceptionTranslator;

　　管理构造函数和析构函数中的异常

　　在全局(静态全局)变量的构造和析构期间，每个 ANSI C++ 都捕获到异常是不可能的。因此，ANSI C++ 不建议在那些其实例可能被定义为全局实例(静态全局实例)的类的构造函数和析构函数中抛出异常。换一种说法就是永远都不要为那些其构造函数和析构函数可能抛出异常的类定义全局(静态全局)实例。不过，如果假定有一个特定编译器和一个特定系统，那么可能可以这样做，幸运的是，对于Linux 上的 GCC，恰好是这种情况。

　　使用 ExceptionHandler 类可以展示这一点，该类也采用了 singleton 设计模式。其构造函数注册了一个未捕获的处理程序。因为每次只能有一个未捕获的处理程序处理一个活动进程，构造函数应该只被调用一次，因此要采用 singleton 模式。应该在定义有问题的实际全局(静态全局)变量之前定义 ExceptionHandler 的全局(静态全局)实例。

　　清单 3. 处理构造函数中的异常

　　class ExceptionHandler

　　{

　　private:

　　class SingleTonHandler

　　{

　　public:

　　SingleTonHandler()

　　{

　　set_terminate(Handler);

　　}

　　static void Handler()

　　{

　　// Exception from construction/destruction of global variables try

　　{

　　// re-throw throw;

　　}

　　catch (SegmentationFault &)

　　{

　　cout << “SegmentationFault” << endl;

　　}

　　catch (FloatingPointException &)

　　{

　　cout << “FloatingPointException” << endl;

　　}

　　catch (...)

　　{

　　cout << “Unknown Exception” << endl;

　　}

　　//if this is a thread performing some core activity

　　abort();

　　// else if this is a thread used to service requests

　　// pthread_exit();

　　}

　　};

　　public:

　　ExceptionHandler()

　　{

　　static SingleTonHandler s_objHandler;

　　}

　　};

　　//////////////////////////////////////////////////////////////////////////

　　class A

　　{

　　public:

　　A()

　　{

　　//int i = 0, j = 1/i;

　　*(int *)0 = 0;

　　}

　　};

　　// Before defining any global variable, we define a dummy instance

　　// of ExceptionHandler object to make sure that

　　// ExceptionHandler::SingleTonHandler::SingleTonHandler() is

　　invoked

　　ExceptionHandler g_objExceptionHandler;

　　A g_a;

　　//////////////////////////////////////////////////////////////////////////

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

　　{

　　return 0;

　　}

　　处理多线程程序中的异常

　　有时一些异常没有被捕获，这将造成进程异常中止。不过很多时候，进程包含多个线程，其中少数线程执行核心应用程序逻辑，同时，其余线程为外部请求提供服务。如果服务线程因编程错误而没有处理某个异常，则会造成整个应用程序崩溃。这一点可能是不受人们欢迎的，因为它会通过向应用程序传送不合法的请求而助长拒绝服务攻击。为了避免这一点，未捕获处理程序可以决定是请求异常中止调用，还是请求线程退出调用。清单3 中 ExceptionHandler::SingleTonHandler::Handler() 函数的末尾处展示了该处理程序。

　　结束语

　　我简单地讨论了少许 C++ 编程设计模式，以便更好地执行以下任务：

　　·在抛出异常的时候追踪异常的来源。

　　·将信号从内核程序转换成 C++ 异常。

　　·捕获构造和/或析构全局变量期间抛出的异常。

　　·多线程进程中的异常处理。

　　C++语言的创建初衷是“a better C”，但是这并不意味着C++中类似C语言的全局变量和函数所采用的编译和连接方式与C语言完全相同。作为一种欲与C兼容的语言，C++保留了一部分过程式语言的特点(被世人称为“不彻底地面向对象”)，因而它可以定义不属于任何类的全局变量和函数。但是，C++毕竟是一种面向对象的程序设计语言，为了支持函数的重载，C++对全局函数的处理方式与C有明显的不同。

　　2.从标准头文件说起

　　某企业曾经给出如下的一道面试题：

　　面试题:为什么标准头文件都有类似以下的结构？

　　#ifndef __INCvxWorksh

　　#define __INCvxWorksh

　　#ifdef __cplusplus

　　extern "C" {

　　#endif

　　/*...*/

　　#ifdef __cplusplus

　　}

　　#endif

　　#endif /* __INCvxWorksh */

　　分析

　　显然，头文件中的编译宏“#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif” 的作用是防止该头文件被重复引用。

　　那么

　　#ifdef __cplusplus

　　extern "C" {

　　#endif

　　#ifdef __cplusplus

　　}

　　#endif

　　的作用又是什么呢？我们将在下文一一道来。

　　3.深层揭密extern "C"

　　extern "C" 包含双重含义，从字面上即可得到：首先，被它修饰的目标是“extern”的；其次，被它修饰的目标是“C”的。让我们来详细解读这两重含义。

　　被extern "C"限定的函数或变量是extern类型的；

　　extern是C/C++语言中表明函数和全局变量作用范围(可见性)的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。记住，下列语句：

　　extern int a;

　　仅仅是一个变量的声明，其并不是在定义变量a，并未为a分配内存空间。变量a在所有模块中作为一种全局变量只能被定义一次，否则会出现连接错误。

　　通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在连接阶段中从模块A编译生成的目标代码中找到此函数。

　　与extern对应的关键字是static，被它修饰的全局变量和函数只能在本模块中使用。因此，一个函数或变量只可能被本模块使用时，其不可能被extern “C”修饰。

　　被extern "C"修饰的变量和函数是按照C语言方式编译和连接的；

　　未加extern “C”声明时的编译方式

　　首先看看C++中对类似C的函数是怎样编译的。

　　作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：

　　void foo( int x, int y );

　　该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字(不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”)。

　　foo_int_int 这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。

　　同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。

　　未加extern "C"声明时的连接方式

　　假设在C++中，模块A的头文件如下：

　　// 模块A头文件　moduleA.h

　　#ifndef MODULE_A_H

　　#define MODULE_A_H

　　int foo( int x, int y );

　　#endif

　　在模块B中引用该函数：

　　// 模块B实现文件　moduleB.cpp

　　#include "moduleA.h"

　　foo(2,3);

　　实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！

　　加extern "C"声明后的编译和连接方式

　　加extern "C"声明后，模块A的头文件变为：

　　// 模块A头文件　moduleA.h

　　#ifndef MODULE_A_H

　　#define MODULE_A_H

　　extern "C" int foo( int x, int y );

　　#endif

　　在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：

　　(1)模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；

　　(2)连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。

　　如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。

　　所以，可以用一句话概括extern “C”这个声明的真实目的(任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题)：

　　实现C++与C及其它语言的混合编程。

　　明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧。

　　4.extern "C"的惯用法

　　(1)在C++中引用C语言中的函数和变量，在包含C语言头文件(假设为cExample.h)时，需进行下列处理：

　　extern "C"

　　{

　　#include "cExample.h"

　　}

　　而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。

　　笔者编写的C++引用C函数例子工程中包含的三个文件的源代码如下：

　　/* c语言头文件：cExample.h */

　　#ifndef C_EXAMPLE_H

　　#define C_EXAMPLE_H

　　extern int add(int x,int y);

　　#endif

　　/* c语言实现文件：cExample.c */

　　#include "cExample.h"

　　int add( int x, int y )

　　{

　　return x + y;

　　}

　　// c++实现文件，调用add：cppFile.cpp

　　extern "C"

　　{

　　#include "cExample.h"

　　}

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

　　{

　　add(2,3);

　　return 0;

　　}

　　如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern "C" {　}。

　　(2)在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern "C"函数声明为extern类型。

　　笔者编写的C引用C++函数例子工程中包含的三个文件的源代码如下：

　　//C++头文件 cppExample.h

　　#ifndef CPP_EXAMPLE_H

　　#define CPP_EXAMPLE_H

　　extern "C" int add( int x, int y );

　　#endif

　　//C++实现文件 cppExample.cpp

　　#include "cppExample.h"

　　int add( int x, int y )

　　{

　　return x + y;

　　}

　　/* C实现文件 cFile.c

　　/* 这样会编译出错：#include "cExample.h" */

　　extern int add( int x, int y );

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

　　{

　　add( 2, 3 );

　　return 0;

　　}

　　如果深入理解了第3节中所阐述的extern "C"在编译和连接阶段发挥的作用，就能真正理解本节所阐述的从C++引用C函数和C引用C++函数的惯用法。

　　1. 常见用法。

　　2. 取指定长度的字符串。如在下例中，取最大长度为4字节的字符串。

　　3. 取到指定字符为止的字符串。如在下例中，取遇到空格为止字符串。

　　4. 取仅包含指定字符集的字符串。如在下例中，取仅包含1到9和小写字母的字符串。

　　5. 取到指定字符集为止的字符串。如在下例中，取遇到大写字母为止的字符串。

1.字符映射(Character Mapping)

    文件中的物理源字符被映射到源字符集中，其中包括三字符运算符的替换、控制字符(行尾的回车换行)的替换。许多非美式键盘不支持基本源字符集中的一些字符，文件中可用三字符来代替这些基本源字符，以??为前导。但如果所用键盘是美式键盘，有些编译器可能不对三字符进行查找和替换，需要增加-trigraphs编译参数。在C++程序中，任何不在基本源字符集中的字符都被它的通用字符名替换。

2.行合并(Line Splicing)

    以反斜杠\结束的行和它接下来的行合并。

3.标记化(Tokenization)

    每一条注释被一个单独的空字符所替换。C++双字符运算符被识别为标记(为了开发可读性更强的程序，C++为非ASCII码开发者定义了一套双字符运算符集和新的保留字集)。源代码被分析成预处理标记。

4.预处理(Preprocessing)

    调用预处理指令并扩展宏。使用#include指令包含的文件，重复步骤1到4。上述四个阶段统称为预处理阶段。

5.字符集映射(Character-set Mapping)

    源字符集成员、转义序列被转换成等价的执行字符集成员。例如：'\a'在ASCII环境下会被转换成值为一个字节，值为7。

6.字符串连接(String Concatenation)

    相邻的字符串被连接。例如："""hahaha""huohuohuo"将成为"hahahahuohuohuo"。

7.翻译(Translation)

    进行语法和语义分析编译，并翻译成目标代码。

8.处理模板

    处理模板实例。

9.连接(Linkage)

    解决外部引用的问题，准备好程序映像以便执行。

也只有这三类可以定义它们各自的对象，然后“.”出来或者“->”出来，C++中只有这三类了。

对于它们各自来说，在一个类的内部都可以有三种方式来定义它们，比如对于union，

第一种方式：//定义了一个union类型，并且定义了一个属于该类型的对象un，因此sizeof(X)==4

class X{

public:

    union UN{

       int m_nX;

       char* pchar;

    }un;

};

第二种方式：//定义了一个union类型，但并没有定义属于该类型的任何对象，因此sizeof(X)==0

class X{

public:

    union UN{

       int m_nX;

       char* pchar;

    };

};

第三种方式：//定义了一个匿名的union类型，因此也就只能在X内部使用了，并且此种情况隐含着已经

在X中定义了一个属于该匿名union类型的对象，因此sizeof(X)==4，并且此种情况最为特殊，可以直接

通过类X的对象来使用m_nX和pchar，例如

class X{

public:

    union {

       int m_nX;

       char* pchar;

    };

};

X x;

x.m_nX=10;

x.pchar="Hello World!";

对于前两种方式，都在类的内部定义了一个新的具有名字的型别，因此可以用这种新的类型来定义对应

于该类型的对象，例如：X::UN myun;但是这种定义是要求类内部的union在定义时的修饰符为public，

否则就不能在类外部定义属于他们的对象，而只能在给类X内部使用了。

同理也可以知道在类内部通过typedef定义出来的新型别也是如此。

需要说明的是，union用类里以第三种定义的方式出现的话，会有很奇妙的效果，非常奇妙，或许在今

后的编程过程中可以加以利用。m_nX和pchar共享一块4个字节的内存，只要不是同时需要m_nX和pchar

出现的情况都可以只利用它们其中的一个，从而节省了内存开销。