road420

函数指针的声明和回调的实现

函数指针的声明和回调的实现

   程序员常常需要实现回调。本文将讨论函数指针的基本原则并说明如何使用函数指针实现回调。注意这里针对的是普通的函数，不包括完全依赖于不同语法和语义规则的类成员函数（类成员指针将在另文中讨论）。

声明函数指针

   回调函数是一个程序员不能显式调用的函数；通过将回调函数的地址传给调用者从而实现调用。要实现回调，必须首先定义函数指针。尽管定义的语法有点不可思议，但如果你熟悉函数声明的一般方法，便会发现函数指针的声明与函数声明非常类似。请看下面的例子：

void f()；// 函数原型

上面的语句声明了一个函数，没有输入参数并返回void。那么函数指针的声明方法如下：

void (*) ();

   让我们来分析一下，左边圆括弧中的星号是函数指针声明的关键。另外两个元素是函数的返回类型（void）和由边圆括弧中的入口参数（本例中参数是空）。注意本例中还没有创建指针变量-只是声明了变量类型。目前可以用这个变量类型来创建类型定义名及用sizeof表达式获得函数指针的大小：

// 获得函数指针的大小
unsigned psize = sizeof (void (*) ());

// 为函数指针声明类型定义
typedef void (*pfv) ();

pfv是一个函数指针，它指向的函数没有输入参数，返回类行为void。使用这个类型定义名可以隐藏复杂的函数指针语法。

指针变量应该有一个变量名：

void (*p) (); //p是指向某函数的指针

   p是指向某函数的指针，该函数无输入参数，返回值的类型为void。左边圆括弧里星号后的就是指针变量名。有了指针变量便可以赋值，值的内容是署名匹配的函数名和返回类型。例如：

void func()
{
/* do something */
}
p = func;

p的赋值可以不同，但一定要是函数的地址，并且署名和返回类型相同。

传递回调函数的地址给调用者

   现在可以将p传递给另一个函数（调用者）- caller()，它将调用p指向的函数，而此函数名是未知的：

void caller(void(*ptr)())
{
ptr(); /* 调用ptr指向的函数 */
}
void func();
int main()
{
p = func;
caller(p); /* 传递函数地址到调用者 */
}

   如果赋了不同的值给p（不同函数地址），那么调用者将调用不同地址的函数。赋值可以发生在运行时，这样使你能实现动态绑定。

调用规范

   到目前为止，我们只讨论了函数指针及回调而没有去注意ANSI C/C++的编译器规范。许多编译器有几种调用规范。如在Visual C++中，可以在函数类型前加_cdecl，_stdcall或者_pascal来表示其调用规范（默认为_cdecl）。C++ Builder也支持_fastcall调用规范。调用规范影响编译器产生的给定函数名，参数传递的顺序（从右到左或从左到右），堆栈清理责任（调用者或者被调用者）以及参数传递机制（堆栈，CPU寄存器等）。

   将调用规范看成是函数类型的一部分是很重要的；不能用不兼容的调用规范将地址赋值给函数指针。例如：

// 被调用函数是以int为参数，以int为返回值
__stdcall int callee(int);

// 调用函数以函数指针为参数
void caller( __cdecl int(*ptr)(int));

// 在p中企图存储被调用函数地址的非法操作
__cdecl int(*p)(int) = callee; // 出错

   指针p和callee()的类型不兼容，因为它们有不同的调用规范。因此不能将被调用者的地址赋值给指针p，尽管两者有相同的返回值和参数列。

posted @ 2006-10-27 22:10 深邃者 阅读(125) | 评论 (0) | 编辑 收藏

对象的动态分配

     摘要: 对象的动态分配（Dynamically Allocated Object） Posted on 2006-08-05 12:55 一秋草木 阅读(291) 评论(4)  编辑 收藏收藏至365Key 所属分类: C++ --> 1 、对象的分类 ...  阅读全文

posted @ 2006-10-23 19:54 深邃者 阅读(349) | 评论 (0) | 编辑 收藏

关键字

mutable关键字

关键字mutable是C++中一个不常用的关键字,他只能用于类的非静态和非常量数据成员
我们知道一个对象的状态由该对象的非静态数据成员决定,所以随着数据成员的改变,
对像的状态也会随之发生变化!

如果一个类的成员函数被声明为const类型,表示该函数不会改变对象的状态,也就是
该函数不会修改类的非静态数据成员.但是有些时候需要在该类函数中对类的数据成员
进行赋值.这个时候就需要用到mutable关键字了

例如:
class Demo
{
public:
    Demo(){}
    ~Demo(){}
public:
    bool getFlag() const
    {
        m_nAccess++;
        return m_bFlag;
    }
private:
    int  m_nAccess;
    bool m_bFlag;
};

int main()
{
    return 0;
}

编译上面的代码会出现 error C2166: l-value specifies const object的错误
说明在const类型的函数中改变了类的非静态数据成员.

这个时候需要使用mutable来修饰一下要在const成员函数中改变的非静态数据成员
m_nAccess,代码如下:

class Demo
{
public:
    Demo(){}
    ~Demo(){}
public:
    bool getFlag() const
    {
        m_nAccess++;
        return m_bFlag;
    }
private:
    mutable int  m_nAccess;
    bool m_bFlag;
};

int main()
{
    return 0;
}

这样再重新编译的时候就不会出现错误了!

 

 

volatile关键字

volatile是c/c++中一个鲜为人知的关键字,该关键字告诉编译器不要持有变量的临时拷贝,它可以适用于基础类型
如：int,char,long......也适用于C的结构和C++的类。当对结构或者类对象使用volatile修饰的时候，结构或者
类的所有成员都会被视为volatile.

使用volatile并不会否定对CRITICAL_SECTION,Mutex,Event等同步对象的需要
例如：
int i;
i = i + 3;
无论如何，总是会有一小段时间，i会被放在一个寄存器中，因为算术运算只能在寄存器中进行。一般来说，volatitle
关键字适用于行与行之间，而不是放在行内。

我们先来实现一个简单的函数，来观察一下由编译器产生出来的汇编代码中的不足之处，并观察volatile关键字如何修正
这个不足之处。在这个函数体内存在一个busy loop(所谓busy loop也叫做busy waits,是一种高度浪费CPU时间的循环方法)

void getKey(char* pch)
{
 while (*pch == 0)
  ;
}

当你在VC开发环境中将最优化选项都关闭之后，编译这个程序，将获得以下结果(汇编代码)
;       while (*pch == 0)
$L27
 ; Load the address stored in pch
 mov eax, DWORD PTR _pch$[ebp]
 ; Load the character into the EAX register
 movsx eax, BYTE PTR [eax]
 ; Compare the value to zero
 test eax, eax
 ; If not zero, exit loop
 jne $L28
 ;
 jmp $L27
$L28
;}

这段没有优化的代码不断的载入适当的地址，载入地址中的内容，测试结果。效率相当的低，但是结果非常准确

现在我们再来看看将编译器的所有最优化选项开关都打开以后，重新编译程序，生成的汇编代码，和上面的代码
比较一下有什么不同
;{
 ; Load the address stored in pch
 mov eax, DWORD PTR _pch$[esp-4]
 ; Load the character into the AL register
 movsx al, BYTE PTR [eax]
; while (*pch == 0)
 ; Compare the value in the AL register to zero
 test al, al
 ; If still zero, try again
 je SHORT $L84
 ;
;}

从代码的长度就可以看出来，比没有优化的情况要短的多。需要注意的是编译器把MOV指令放到了循环之外。这在
单线程中是一个非常好的优化，但是，在多线程应用程序中，如果另一个线程改变了变量的值，则循环永远不会
结束。被测试的值永远被放在寄存器中，所以该段代码在多线程的情况下，存在一个巨大的BUG。解决方法是重新
写一次getKey函数，并把参数pch声明为volatile,代码如下：

void getKey(volatile char* pch)
{
 while (*pch == 0)
  ;
}

这次的修改对于非最优化的版本没有任何影响，下面请看最优化后的结果：

;{
 ; Load the address stored in pch
 mov eax, DWORD PTR _pch$[esp-4]
;       while (*pch == 0)
$L84:
 ; Directly compare the value to zero
 cmp BYTE PTR [eax], 0
 ; If still zero, try again
 je SHORT $L84
 ;
;}

这次的修改结果比较完美，地址不会改变，所以地址声明被移动到循环之外。地址内容是volatile,所以每次循环
之中它不断的被重新检查。

把一个const volatile变量作为参数传递给函数是合法的。如此的声明意味着函数不能改变变量的值，但是变量的
值却可以被另一个线程在任何时间改变掉。

explicit关键字

我们在编写应用程序的时候explicit关键字基本上是很少使用,它的作用是"禁止单参数构造函数"被用于自动型别转换,
其中比较典型的例子就是容器类型,在这种类型的构造函数中你可以将初始长度作为参数传递给构造函数.
例如:
你可以声明这样一个构造函数
class Array
{
public:
 explicit Array(int size);
 ......
};
在这里explicit关键字起着至关重要的作用,如果没有这个关键字的话,这个构造函数有能力将int转换成Array.一旦这种
情况发生,你可以给Array支派一个整数值而不会引起任何的问题,比如:
Array arr;
...
arr = 40;
此时,C++的自动型别转换会把40转换成拥有40个元素的Array,并且指派给arr变量,这个结果根本就不是我们想要的结果.如果
我们将构造函数声明为explicit,上面的赋值操作就会导致编译器报错,使我们可以及时发现错误.
需要注意的是:explicit同样也能阻止"以赋值语法进行带有转型操作的初始化";
例如:
Array arr(40);//正确
Array arr = 40;//错误

看一下以下两种操作:
X x;
Y y(x);//显式类型转换
另一种
X x;
Y y = x;//隐式类型转换

这两种操作存在一个小小的差别,第一种方式式通过显式类型转换,根据型别x产生了型别Y的新对象;第二种方式通过隐式转换
产生了一个型别Y的新对象.
explicit关键字的应用主要就是上面所说的构造函数定义种,参考该关键字的应用可以看看STL源代码,其中大量使用了该关键字

 

__based关键字

该关键字主要用来解决一些和共享内存有关的问题,它允许指针被定义为从某一点开始算的32位偏移值,而不是内存种的绝对位置
举个例子:

typedef struct tagDEMOSTRUCT {
 int a;
 char sz[10];
} DEMOSTRUCT, * PDEMOSTRUCT;

HANDLE hFileMapping = CreateFileMapping(...);
LPVOID lpShare = (LPDWORD)MapViewOfFile(...);

DEMOSTRUCT __based(lpShare)* lpDemo;

上面的例子声明了一个指针lpDemo,内部储存的是从lpShare开始的偏移值,也就是lpHead是以lpShare为基准的偏移值.
上面的例子种的DEMOSTRUCT只是随便定义的一个结构,用来代表任意的结构.

虽然__based指针使用起来非常容易,但是,你必须在效率上付出一定的代价.每当你用__based指针处理数据,CPU都必须
为它加上基地址,才能指向真正的位置.

在这里我只是介绍了几个并不时很常见的关键字的意义即用法,其他那些常见的关键字介绍他们的文章已经不少了在这里
就不再一一介绍了.希望这些内容能对大家有一定的帮助!

posted @ 2006-10-22 16:07 深邃者 阅读(166) | 评论 (0) | 编辑 收藏

结构体的对齐

由一道面试题来看 Struct 的对界

 

本文节选自宋宝华的C/C++的struct深层探索一文，本人对其所描述的struct对齐比较喜欢，为此转来与大家分享，原文见http://blog.donews.com/21cnbao/archive/2005/09/08/544877.aspx

 

Intel 、微软等公司曾经出过一道类似的面试题：

1. #include <iostream.h>

2. #pragma pack(8)

3. struct example1

4. {

5.     short a;

6.     long b;

7. };

8. struct example2

9. {

10.          char c;

11.          example1 struct1;

12.          short e;

13. };

14. #pragma pack()

 

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

16. {

17.          example2 struct2;

18.   cout << sizeof(example1) << endl;

19.   cout << sizeof(example2) << endl;

20.   cout << (unsigned int)(&struct2.struct1) - (unsigned int)(&struct2)

<< endl;

21. return 0;

22. }

问程序的输入结果是什么？

答案是：

8

16

4

不明白？还是不明白？下面一一道来：

1 、 自然对界

struct 是一种复合数据类型，其构成元素既可以是基本数据类型（如 int 、 long 、 float 等）的变量，也可以是一些复合数据类型（如 array 、 struct 、 union 等）的数据单元。对于结构体，编译器会自动进行成员变量的对齐，以提高运算效率。缺省情况下，编译器为结构体的每个成员按其自然对界（ natural alignment ）条件分配空间。各个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。

自然对界 (natural alignment) 即默认对齐方式，是指按结构体的成员中 size 最大的成员对齐。

例如：

struct naturalalign

{

char a;

short b;

char c;

};

在上述结构体中， size 最大的是 short ，其长度为 2 字节，因而结构体中的 char 成员 a 、 c 都以 2 为单位对齐， sizeof(naturalalign) 的结果等于 6 ；

如果改为：

struct naturalalign

{

char a;

int b;

char c;

};

其结果显然为 12 。

 

2 、 指定对界

一般地，可以通过下面的方法来改变缺省的对界条件：

· 使用伪指令 #pragma pack (n) ，编译器将按照 n 个字节对齐；

· 使用伪指令 #pragma pack () ，取消自定义字节对齐方式。

注意：如果 #pragma pack (n) 中指定的 n 大于结构体中最大成员的 size ，则其不起作用，结构体仍然按照 size 最大的成员进行对界。

例如：

#pragma pack (n)

struct naturalalign

{

char a;

int b;

char c;

};

#pragma pack ()

当 n 为 4 、 8 、 16 时，其对齐方式均一样， sizeof(naturalalign) 的结果都等于 12 。而当 n 为 2 时，其发挥了作用，使得 sizeof(naturalalign) 的结果为 8 。

posted @ 2006-10-21 13:21 深邃者 阅读(192) | 评论 (0) | 编辑 收藏

结构体高级特性

     摘要: C/C++ 结构体的一个高级特性 ―― 指定成员的位数 ...  阅读全文

posted @ 2006-10-21 13:06 深邃者 阅读(415) | 评论 (0) | 编辑 收藏

关于局部与全局及静态的关系

1.在一个函数内部定义的变量是内部变量，它只在本函数范围内有效，在此函数外面是不能使用这个变量，称之为 "局部变量"。形式参数也属于局部变量。在函数中的一个程序块（如某个复合语句｛...｝）定义的局部变量只在这个程序块中有效，出了程序块后就无效。
2.有时希望函数中的局部变量的值在函数调用之后不消失而保留原值，在下一次该函数调用时该变量已有值，这时就该制定该局部变量为"静态局部变量"，用static加以说明。
3.在函数之外定义的变量称之为全局变量，全局变量可以为本文件中其他函数所共用，其有效范围为：从定义变量开始到本源文件结束。如果在定义点之前的函数想应用该全局变量，则应该在该函数中使用关键字 extern作外部变量说明，表示该变量在函数外部定义在函数内部可以使用它。如果在同一个源文件中，全局变量和局部变量同名，则在局部变量作用范围内，全局变量不起作用。如果在其它文件中要引用该文件的全局变量，则需要在应用它的文件中，用extern作说明。
4.所谓静态全局变量，就是希望某些全局变量只限定于被本文件引用，而不被其它文件引用，这时可以在定义全局变量的时候在前面加一个static说明，

 5 按存储区域分，全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域，局部变量存放在内存的栈区。
  6 按作用域分，全局变量在整个工程文件内都有效；静态全局变量只在定义它的文件内有效；静态局部变量只在定义它的函数内有效，只是程序仅分配一次内存，函数返回后，该变量不会消失；局部变量在定义它的函数内有效，但是函数返回后失效。
  7 全局变量和静态变量如果没有手工初始化，则由编译器初始化为0。局部变量的值不可知。
8 举个例子：
int a;  /*全局*/
static int b;  /*静态全局*/
int main()
{
}
这段代码如果是写在file.c里面的，那么file2.c就不能调用b;
但是file2.c中可以通过声明外部变量extent a;

9.静态全局变量 　　全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用， 因此可以避免在其它源文件中引起错误。从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 限制了它 的使用范围。因此static 这个说明符在不同的地方所起的作用是不同的。应予以注意。

10 代码
//test.cpp
＃i nclude <iostream.h>
extern int a;//变量声明，不是定义
static int b=5;
void func1()
{
  cout<<b<<endl<<a<<endl;//结果为5
}

//main.cpp
int a;
int b=10;
void func2()
{
  static int i;
  i++;
  cout<<i<<endl;
}

void func1();

void main()
{
  a=20;
  func1();
  func2();
  func2();
}
输出结果为
5
20
1
2

posted @ 2006-09-10 12:11 深邃者 阅读(363) | 评论 (0) | 编辑 收藏

关于sizeof（）

这篇文章转载于 马嘉楠 ，个人认为那位作者写得有可取之处。

1. 定义：
    sizeof是何方神圣？

    sizeof 乃 C/C++ 中的一个操作符（operator）是也。简单说其作用就是返回一个对象或者类型所占的内存字节数。

MSDN上的解释为：

The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type (including aggregate types).This keyword returns a value of type size_t.

    其返回值类型为size_t，在头文件stddef.h中定义。这是一个依赖于编译系统的值，一般定义为

typedef unsigned int size_t;

    世上编译器林林总总，但作为一个规范，它们都会保证char、signed char和unsigned char的sizeof值为1，毕竟char是我们编程能用的最小数据类型。

2. 语法：
    sizeof有三种语法形式，如下：
    1) sizeof( object );    // sizeof( 对象 );
    2) sizeof( type_name ); // sizeof( 类型 );
    3) sizeof object;       // sizeof 对象;

所以，
int i;
sizeof( i );     // ok
sizeof i;        // ok
sizeof( int );   // ok
sizeof int;      // error

既然写法2可以用写法1代替，为求形式统一以及减少我们大脑的负担，第2种写法，忘掉它吧！

实际上，sizeof计算对象的大小也是转换成对对象类型的计算。也就是说，同种类型的不同对象其sizeof值都是一致的。

这里，对象可以进一步延伸至表达式，即sizeof可以对一个表达式求值。编译器根据表达式的最终结果类型来确定大小，一般不会对表达式进行计算。

例如：

sizeof( 2 );        // 2的类型为int，所以等价于 sizeof( int );
sizeof( 2 + 3.14 ); // 3.14的类型为double，2也会被提升成double类型，所以等价于 sizeof( double );

    sizeof也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用。我们来看一个完整的例子：

*********************************************************

char foo()
{
    printf("foo() has been called.\n");
    return 'a';
}
int main()
{
    size_t sz = sizeof( foo() );   // foo() 的返回值类型为char，所以sz = sizeof(char)，但函数foo()并不会被调用
    printf("sizeof( foo() ) = %d\n", sz);
}

*********************************************************

C99标准规定，函数、不能确定类型的表达式以及位域（bit-field）成员不能被计算sizeof值，即下面这些写法都是错误的：

    sizeof( foo );     // error
    void foo2() { }
    sizeof( foo2() );  // error
    struct S
    {
        unsigned int f1 : 1;
        unsigned int f2 : 5;
        unsigned int f3 : 12;
    };
    sizeof( S.f1 );   // error

3. sizeof的常量性

    sizeof的计算发生在编译时刻，所以它可以被当作常量表达式使用。如：

char ary[ sizeof( int ) * 10 ];   // ok

最新的C99标准规定sizeof也可以在运行时刻进行计算。如下面的程序在Dev-C++中可以正确执行：

int n;
n = 10;        // n动态赋值
char ary[n];   // C99也支持数组的动态定义
printf("%d\n", sizeof(ary)); // ok. 输出10

但在没有完全实现C99标准的编译器中就行不通了，上面的代码在VC6中就通不过编译。所以我们最好还是认为sizeof是在编译期执行的，这样不会带来错误，让程序的可移植性强些。

4. 基本数据类型的sizeof

这里的基本数据类型指short、int、long、float、double这样的简单内置数据类型。由于它们都是和系统相关的，所以在不同的系统下取值可能不同。这务必引起我们的注意，尽量不要在这方面给自己程序的移植造成麻烦。

一般的，在32位编译环境中，sizeof(int)的取值为4。

5. 指针变量的sizeof

学过数据结构的你应该知道指针是一个很重要的概念，它记录了另一个对象的地址。既然是来存放地址的，那么它当然等于计算机内部地址总线的宽度。所以在32位计算机中，一个指针变量的返回值必定是4（注意结果是以字节为单位）。可以预计，在将来的64位系统中指针变量的sizeof结果为8。

*********************************************************

char* pc = "abc";
int* pi;
string* ps;
char** ppc = &pc;
void (*pf)(); // 函数指针
sizeof( pc ); // 结果为4
sizeof( pi ); // 结果为4
sizeof( ps ); // 结果为4
sizeof( ppc );// 结果为4
sizeof( pf ); // 结果为4

*********************************************************

指针变量的sizeof值与指针所指的对象没有任何关系，正是由于所有的指针变量所占内存大小相等，所以MFC消息处理函数使用两个参数WPARAM、LPARAM就能传递各种复杂的消息结构（使用指向结构体的指针）。

6. 数组的sizeof

数组的sizeof值等于数组所占用的内存字节数，如：

char a1[] = "abc";
int a2[3];
sizeof( a1 ); // 结果为4，字符 末尾还存在一个NULL终止符
sizeof( a2 ); // 结果为3*4=12（依赖于int）

一些朋友刚开始时把sizeof当作了求数组元素的个数，现在，你应该知道这是不对的。那么应该怎么求数组元素的个数呢？

Easy，通常有下面两种写法：

int c1 = sizeof( a1 ) / sizeof( char );    // 总长度/单个元素的长度
int c2 = sizeof( a1 ) / sizeof( a1[0]);    // 总长度/第一个元素的长度

写到这里，提一问，下面的c3，c4值应该是多少呢？

*********************************************************

void foo3(char a3[3])
{
    int c3 = sizeof( a3 ); // c3 ==
}
void foo4(char a4[])
{
    int c4 = sizeof( a4 ); // c4 ==
}

*********************************************************

也许当你试图回答c4的值时已经意识到c3答错了，是的，c3!=3。

这里函数参数a3已不再是数组类型，而是蜕变成指针。相当于char* a3，为什么仔细想想就不难明白。

我们调用函数foo1时，程序会在栈上分配一个大小为3的数组吗？不会！

数组是“传址”的，调用者只需将实参的地址传递过去，所以a3自然为指针类型（char*），c3的值也就为4。

7.string的sizeof
一个string的大小与它所指向的字符串的长度无关。

*********************************************************
string st1("blog.sina.com.cn");
string st2("majianan");
string st3;
string *ps = &st1;
cout << "st1: " << sizeof(st1) << endl;
cout << "st2: " << sizeof(st2) << endl;
cout << "st3: " << sizeof(st3) << endl;
cout << "ps: " << sizeof(ps) << endl;
cout << "*ps: " << sizeof(*ps) << endl;
*********************************************************

输出结果为：
st1： 28
st2： 28
st3： 28
ps： 4
*ps： 28
*********************************************************
对于不同的STL，String类的结构定义会有所不同
所以不同的工具，例如VC++，和.NET，结果会有所不同，
在VC++6.0中（我的机器）结果是16
在.NET2003中结果是28
但是对于同一个编译器，那么它的结果都是一定的


8.引用的sizeof

sizeof操作符应用在引用类型上的时候，返回的是包含被引用对象所需的内存长度（即被引用对象的大小）

*********************************************************
cout << "short:\t" << sizeof(short) << endl;
cout << "short*:\t" << sizeof(short*) << endl;
cout << "short&:\t" << sizeof(short&) << endl;
cout << "short[4]:\t" << sizeof(short[4]) << endl;
cout << "int&:\t" << sizeof(int&) << endl;
*********************************************************

输出结果为：
short： 2
short*： 4
short&： 2
short[4]： 8
int&： 4


9. 结构体的sizeof

这是初学者问得最多的一个问题，所以这里有必要多费点笔墨。让我们先看一个结构体：

struct S1
{
    char c;
    int i;
};

问sizeof(s1)等于多少？

聪明的你开始思考了，char占1个字节，int占4个字节，那么加起来就应该是5。

是这样吗？

你在你机器上试过了吗？

也许你是对的，但很可能你是错的！

VC6中按默认设置得到的结果为8。

    Why？为什么受伤的总是我？

请不要沮丧，我们来好好琢磨一下sizeof的定义 —— sizeof的结果等于对象或者类型所占的内存字节数。好吧，那就让我们来看看S1的内存分配情况：

S1 s1 = { 'a', 0xFFFFFFFF };

定义上面的变量后，加上断点，运行程序，观察s1所在的内存，你发现了什么？

以我的VC6.0为例，s1的地址为0x0012FF78，其数据内容如下：

0012FF78: 61 CC CC CC FF FF FF FF

发现了什么？怎么中间夹杂了3个字节的CC？

看看MSDN上的说明：

When applied to a structure type or variable, sizeof returns the actual size, which may include padding bytes inserted for alignment.

原来如此，这就是传说中的字节对齐啊！一个重要的话题出现了。

为什么需要字节对齐？

计算机组成原理教导我们，这样有助于加快计算机的取数速度，否则就得多花指令周期了。

为此，编译器默认会对结构体进行处理（实际上其它地方的数据变量也是如此），让宽度为2的基本数据类型（short等）都位于能被2整除的地址上，让宽度为4的基本数据类型（int等）都位于能被4整除的地址上。以此类推，这样，两个数中间就可能需要加入填充字节，所以整个结构体的sizeof值就增长了。

让我们交换一下S1中char与int的位置：

struct S2
{
    int i;
    char c;
};

看看sizeof(S2)的结果为多少？怎么还是8。

再看看内存，原来成员c后面仍然有3个填充字节。

这又是为什么啊？别着急，下面总结规律。

    字节对齐的细节和编译器实现相关，但一般而言，满足三个准则：
    1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
    2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；
    3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）。

    对于上面的准则，有几点需要说明：
1) 前面不是说结构体成员的地址是其大小的整数倍，怎么又说到偏移量了呢？

因为有了第1点存在，所以我们就可以只考虑成员的偏移量，这样思考起来简单。想想为什么。

结构体某个成员相对于结构体首地址的偏移量可以通过宏offsetof()来获得，这个宏也在stddef.h中定义，如下：

#define offsetof(s,m) (size_t)&(((s *)0)->m)

例如，想要获得S2中c的偏移量，方法为

size_t pos = offsetof(S2, c);// pos等于4

2) 基本类型是指前面提到的像char、short、int、float、double这样的内置数据类型。这里所说的“数据宽度”就是指其sizeof的大小。由于结构体的成员可以是复合类型，比如另外一个结构体，所以在寻找最宽基本类型成员时，应当包括复合类型成员的子成员，而不是把复合成员看成是一个整体。但在确定复合类型成员的偏移位置时则是将复合类型作为整体看待。

这里叙述起来有点拗口，思考起来也有点挠头，还是让我们看看例子吧（具体数值仍以VC6为例，以后不再说明）：

struct S3
{
    char c1;
    S1 s;
    char c2;
};

S1的最宽简单成员的类型为int，S3在考虑最宽简单类型成员时是将S1“打散”看的，所以S3的最宽简单类型为int。这样，通过S3定义的变量，其存储空间首地址需要被4整除，整个sizeof(S3)的值也应该被4整除。

c1的偏移量为0，s的偏移量呢？这时s是一个整体，它作为结构体变量也满足前面三个准则，所以其大小为8，偏移量为4，c1与s之间便需要3个填充字节，而c2与s之间就不需要了，所以c2的偏移量为12，算上c2的大小为13，13是不能被4整除的，这样末尾还得补上3个填充字节。最后得到sizeof(S3)的值为16。

    通过上面的叙述，我们可以得到一个公式：
    结构体的大小等于最后一个成员的偏移量加上其大小再加上末尾的填充字节数目，即：

sizeof( struct ) = offsetof( last item ) + sizeof( last item ) + sizeof( trailing padding )

 

int main(void)
{
  A object;
  cout << "sizeof(object) is " << sizeof(object) << endl;
  return 0 ;
}

 

***************************************************************

int main()
{

  A object;
  cout << "sizeof(object) is " << sizeof(object) << endl;
  return 0 ;
}

因为在程序编译期间，就已经为static变量在静态存储区域分配了内存空间，并且这块内存在程序的整个运行期间都存在。

而每次声明了类A的一个对象的时候，为该对象在堆上，根据对象的大小分配内存。

posted @ 2006-09-05 12:21 深邃者 阅读(263) | 评论 (1) | 编辑 收藏

输出程序注释行

 

posted @ 2006-05-09 22:08 深邃者 阅读(358) | 评论 (1) | 编辑 收藏

密码输入匹配问题

 

posted @ 2006-05-09 22:06 深邃者 阅读(234) | 评论 (0) | 编辑 收藏

万年历

 

posted @ 2006-05-09 22:03 深邃者 阅读(229) | 评论 (0) | 编辑 收藏