色噜噜的亚洲男人的天堂,久久精品亚洲中文字幕无码网站,ww亚洲ww在线观看国产

��力力力 — Wed, 06 Jan 2010 03:37:00 GMT

在局部变量前加上“static”关键字，��成了静态局部变量。静态局部变量存攑֜�内存的全局数据区。函数结束时�Q�静态局部变量不会消失，每次该函数调�? �Ӟ��也不会�ؓ光��新分配空间。它始终�ȝ��在全局数据区，直到�E�序�q�行�l�束。静态局部变量的初始化与全局变量�c�M��Q�如果不为其昑ּ�初始化，则C++自动为其初始化�ؓ0�?br /> 静态局部变量与全局变量�׃�n全局数据区，但静态局部变量只在定义它的函��C��可见。静态局部变量与局部变量在存储位置上不同，使得其存在的旉��也不同，��D��对这两者操�?的运行结果也不同�?br /> 例如�Q�下面的�E�序定义了全局变量、静态局部变量和局部变量：
　//*********************
//**　　 ch5_2.cpp　 **
//*********************

　　　　#include

　　　　void func();
int n=1; //全局变量

　　　　void main()
{
static int a; // 静态局部变�?br /> int b= -10; // 局部变�?br /> cout <<"a:" < <<" b:" < <<" n:" < b+=4;
func();
cout <<"a:" < <<" b:" < <<" n:" < n+=10;
func();
}

　　　　void func()
{
static int a=2; // 静态局部变�?br /> int b=5; // 局部变�?br /> a+=2;
n+=12;
b+=5;
cout <<"a:" < <<" b:" < <<" n:" < }

　　�q�行�l�果为：
　　　　a:0 b:-10 n:l
a:4 b:10 n:13
a:0 b:-6 n:13
a:6 b:10 n:35
�E�序中主函数main()两次调用了func()函数�Q�从�q�行�l�果可以看出�Q�程序控制每�ơ进入func()函数�Ӟ��局部变量b都被初始化。而静态局�? 变量a仅在�W�一�ơ调用时被初始化�Q�第二次�q�入该函数时�Q�不再进行初始化�Q�这时它的值是�W�一�ơ调用后的结果�?�? main()函数中的变量a和b与func()函数中的变量a和b�I�间位置是不一��L��Q�所以相应的��g��不一栗��关于变量作用域和可见性的�q�一步讨��W? 章�?br /> 静态局部变量的用途有许多�Q�可以��用它��定某函数是否被调用�q�。��用它保留多次调用的倹{�?/p>

寚w��态局部变量的说明�Q?/font>
(1) 静态局部变量在静态存储区内分配存储单元。在�E�序整个�q�行期间都不释放。而自动变量（卛_��态局部变量）属于动态存储类别，存储在动态存储区�I�间(而不是静态存储区�I�间)�Q�函数调用结束后即释放�?
(2) 为静态局部变量赋初值是在编译时�q�行值的�Q�即只赋初��g��ơ，在程序运行时它已有初倹{��以后每�ơ调用函数时不再重新赋初��D��只是保留上�ơ函数调用结束时�? 倹{��而�ؓ自动变量赋初��|��不是在编译时�q�行的，而是在函数调用时�q�行�Q�每调用一�ơ函数重新给一�ơ初��|��相当于执行一�ơ赋��D��句�?

(3) 如果在定义局部变量时不赋初值的话，寚w��态局部变量来��_��~�译时自动赋初�?(�Ҏ��值型变量)或空字符(对字�W�型变量)。而对自动变量来说�Q�如果不赋初 ��|��则它的值是一个不��定的倹{��这是由于每�ơ函数调用结束后存储单元已释放，下次调用时又重新另分配存储单元，而所分配的单元中的值是不确定的�?
(4) 虽然静态局部变量在函数调用�l�束后仍然存在，但其他函数是不能引用它的�Q�也��是��_��在其他函��C��它是“不可�?#8221;的�?/p>

��力力力 2010-01-06 11:37 发表评论

C/C++ �E�序设计员应聘常见面试试题深入剖�?

��力力力 — Thu, 27 Jul 2006 06:08:00 GMT

C/C++ �E�序设计员应聘常见面试试题深入剖�?

旉��Q?006-5-30 17:06:00

.引言

　　本文的写作目的�ƈ不在于提供C/C++�E�序员求职面试指��|��而旨在从技术上分析面试题的内涵。文中的大多数面试题来自各大论坛�Q�部分试题解�{�也参考了�|�友的意见�?br />
　　许多面试题看似简单，却需要深厚的基本功才能给出完��的解答。企业要求面试者写一个最��单的strcpy函数都可看出面试者在技术上�I�竟辑ֈ�了怎样的程度，我们能真正写好一个strcpy函数吗？我们都觉得自��p��Q�可是我们写出的strcpy很可能只能拿�?0分中�?分。读者可从本文看到strcpy 函数�?分到10分解�{�的例子�Q�看看自己属于什么样的层�ơ。此外，�q�有一些面试题考查面试者敏��L��思维能力�?

　　分析�q�些面试题，本��n包含很强的趣��x��；而作��Z��名研发�h员，通过对这些面试题的深入剖析则可进一步增��w�的内功�?br />
　　2.��N��?br />
　　试题1�Q?br />

void test1()
{
　char string[10];
　char* str1 = "0123456789";
　strcpy( string, str1 );
}

　　试题2�Q?br />

void test2()
{
　char string[10], str1[10];
　int i;
　for(i=0; i<10; i++)
　{
　　str1[i] = 'a';
　}
　strcpy( string, str1 );
}

　　试题3�Q?br />

void test3(char* str1)
{
　char string[10];
　if( strlen( str1 ) <= 10 )
　{
　　strcpy( string, str1 );
　}
}

　　解答�Q?br />
　　试题1字符串str1需�?1个字节才能存放下�Q�包括末��’\0’）�Q�而string只有10个字节的�I�间�Q�strcpy会导致数�l�越界；

　　对试�?�Q�如果面试者指出字�W�数�l�str1不能在数�l�内�l�束可以�l?分；如果面试者指出strcpy(string, str1)调用使得从str1内存起复制到string内存��h��复制的字节数��h��不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10 分；

　　对试�?�Q�if(strlen(str1) <= 10)应改为if(strlen(str1) < 10)�Q�因为strlen的结果未�l�计’\0’所占用�?个字节�?br />
　　剖析�Q?br />
　　考查对基本功的掌握：

　　(1)字符串以’\0’结��；

　　(2)�Ҏ��l�越界把握的敏感度；

　　(3)库函数strcpy的工作方式，如果�~�写一个标准strcpy函数的��d��gؓ10�Q�下面给出几个不同得分的�{�案�Q?br />
　　2�?br />

void strcpy( char *strDest, char *strSrc )
{
　 while( (*strDest++ = * strSrc++) != ‘\0�?);
}

　　4�?br />

void strcpy( char *strDest, const char *strSrc )
//��源字符串加const�Q�表明其��入参敎ͼ��?�?br />{
　 while( (*strDest++ = * strSrc++) != ‘\0�?);
}

　　7�?br />

void strcpy(char *strDest, const char *strSrc)
{
　//�Ҏ��地址和目的地址加非0断言�Q�加3�?br />　assert( (strDest != NULL) && (strSrc != NULL) );
　while( (*strDest++ = * strSrc++) != ‘\0�?);
}

　　10�?br />

//��Z��实现铑ּ�操作�Q�将目的地址�q�回�Q�加3分！

char * strcpy( char *strDest, const char *strSrc )
{
　assert( (strDest != NULL) && (strSrc != NULL) );
　char *address = strDest;
　while( (*strDest++ = * strSrc++) != ‘\0�?);
　　return address;
}

　　�?分到10分的几个�{�案我们可以清楚的看刎ͼ��小的strcpy竟然暗藏着�q�么多玄机，真不是盖的！需要多么扎实的基本功才能写一个完��的strcpy啊！

　　(4)对strlen的掌握，它没有包括字�W�串末尾�?\0'�?br />
　　读者看了不同分值的strcpy版本�Q�应该也可以写出一�?0分的strlen函数了，完美的版本�ؓ�Q?int strlen( const char *str ) //输入参数const

{
　assert( strt != NULL ); //断言字符串地址�?
　int len;
　while( (*str++) != '\0' )
　{
　　len++;
　}
　return len;
}

　　试题4�Q?br />

void GetMemory( char *p )
{
　p = (char *) malloc( 100 );
}

void Test( void )
{
　char *str = NULL;
　GetMemory( str );
　strcpy( str, "hello world" );
　printf( str );
}

　　试题5�Q?br />

char *GetMemory( void )
{
　char p[] = "hello world";
　return p;
}

void Test( void )
{
　char *str = NULL;
　str = GetMemory();
　printf( str );
}

　　试题6�Q?br />

void GetMemory( char **p, int num )
{
　*p = (char *) malloc( num );
}

void Test( void )
{
　char *str = NULL;
　GetMemory( &str, 100 );
　strcpy( str, "hello" );
　printf( str );
}

　　试题7�Q?br />

void Test( void )
{
　char *str = (char *) malloc( 100 );
　strcpy( str, "hello" );
　free( str );
　... //省略的其它语�?br />}

　　解答�Q?br />
　　试题4传入中GetMemory( char *p )函数的�Ş参�ؓ字符串指针，在函数内部修改�Ş参�ƈ不能真正的改变传入�Ş参的��|��执行�?br />

char *str = NULL;
GetMemory( str );

　　后的str仍然为NULL�Q?br />
　　试题5�?br />

char p[] = "hello world";
return p;

　　的p[]数组为函数内的局部自动变量，在函数返回后�Q�内存已�l�被释放。这是许多程序员常犯的错误，其根源在于不理解变量的生存期�?br />
　　试题6的GetMemory避免了试�?的问题，传入GetMemory的参��Cؓ字符串指针的指针�Q�但是在GetMemory中执行申请内存及赋��D��?br />

*p = (char *) malloc( num );

　　后未判断内存是否甌��成功�Q�应加上�Q?br />

if ( *p == NULL )
{
　...//�q�行甌��内存��p�|处理
}

　　试题7存在与试�?同样的问题，在执�?br />

char *str = (char *) malloc(100);

　　后未�q�行内存是否甌��成功的判断；另外�Q�在free(str)后未�|�str为空�Q�导致可能变成一个“野”指针，应加上：

str = NULL;

　　试题6的Test函数中也未对malloc的内存进行释放�?br />
　　剖析�Q?br />
　　试题4�?考查面试者对内存操作的理解程度，基本功扎实的面试者一般都能正��的回答其中50~60的错误。但是要完全解答正确�Q�却也绝非易事�?br />
　　对内存操作的考查主要集中在：

　　�Q?�Q�指针的理解�Q?br />
　　�Q?�Q�变量的生存期及作用范围�Q?br />
　　�Q?�Q�良好的动态内存申请和释放习惯�?br />
　　再看看下面的一�D늨�序有什么错误：

swap( int* p1,int* p2 )
{
　int *p;
　*p = *p1;
　*p1 = *p2;
　*p2 = *p;
}

　　在swap函数中，p是一个“野”指针，有可能指向系�l�区�Q�导致程序运行的崩溃。在VC++中DEBUG�q�行时提�C�错误“Access Violation”。该�E�序应该改�ؓ�Q?br />

swap( int* p1,int* p2 )
{
　int p;
　p = *p1;
　*p1 = *p2;
　*p2 = p;
}

　3.内功�?br />
　　试题1�Q�分别给出BOOL�Q�int�Q�float�Q�指针变�?与“零值”比较的 if 语句�Q�假讑֏�量名为var�Q?br />
　　解答�Q?br />
　　　BOOL型变量：if(!var)

　　　int型变量： if(var==0)

　　　float型变量：

　　　const float EPSINON = 0.00001;

　　　if ((x >= - EPSINON) && (x <= EPSINON)

　　　指针变量�Q�　　if(var==NULL)

　　剖析�Q?br />
　　考查�?值判断的“内功”，BOOL型变量的0判断完全可以写成if(var==0)�Q�而int型变量也可以写成if(!var)�Q�指针变量的判断也可以写成if(!var)�Q�上�q�写法虽然程序都能正��运行，但是未能清晰地表辄��序的意思�?

　　const关键字至��有下列n个作用：

　　�Q?�Q�欲��L��一个变量被改变�Q�可以��用const关键字。在定义该const变量�Ӟ��通常需要对它进行初始化�Q�因��Z��后就没有��Z��再去改变它了�Q?br />
　　�Q?�Q�对指针来说�Q�可以指定指针本�w��ؓconst�Q�也可以指定指针所指的数据为const�Q�或二者同时指定�ؓconst�Q?br />
　　�Q?�Q�在一个函数声明中�Q�const可以修饰形参�Q�表明它是一个输入参敎ͼ�在函数内部不能改变其��|��

　　�Q?�Q�对于类的成员函敎ͼ�若指定其为const�c�d��Q�则表明其是一个常函数�Q�不能修改类的成员变量；

　　�Q?�Q�对于类的成员函敎ͼ�有时候必��L��定其�q�回��gؓconst�c�d��Q�以使得其返回��g��为“左值”。例如：

const classA operator*(const classA& a1,const classA& a2);

　　operator*的返回结果必��L��一个const对象。如果不是，�q�样的变态代码也不会�~�译出错�Q?br />

classA a, b, c;
(a * b) = c; // 对a*b的结果赋�?/td>

　　操作(a * b) = c昄��不符合编�E�者的初衷�Q�也没有��M��意义�?br />
　　剖析�Q?br />
　　惊讶吗？��小的static和const居然有这么多功能�Q�我们能回答几个�Q�如果只能回�{?~2个，那还真得闭关再好好修��g��点{�?br />
　　�q�个题可以考查面试者对�E�序设计知识的掌握程度是初��、中�U�还是比较深入，没有一定的知识�q�度和深度，不可能对�q�个问题�l�出全面的解�{�。大多数人只能回�{�出static和const关键字的部分功能�?br />
　　4.技巧题

　　试题1�Q�请写一个C函数�Q�若处理器是Big_endian的，则返�?�Q�若是Little_endian的，则返�?

　　解答�Q?br />

int checkCPU()
{
　{
　　union w
　　{
　　　int a;
　　　char b;
　　} c;
　　c.a = 1;
　　return (c.b == 1);
　}
}

　　剖析�Q?br />
　　嵌入式系�l�开发者应该对Little-endian和Big-endian模式非常了解。采用Little-endian模式的CPU�Ҏ��作数的存放方式是从低字节到高字节�Q�而Big-endian模式�Ҏ��作数的存放方式是从高字节��C��字节。例如，16bit宽的�?x1234在Little- endian模式CPU内存中的存放方式�Q�假设从地址0x4000开始存放）为：

内存地址	存放内容
0x4000	0x34
0x4001	0x12

　　而在Big-endian模式CPU内存中的存放方式则�ؓ�Q?br />

内存地址	存放内容
0x4000	0x12
0x4001	0x34

　　32bit宽的�?x12345678在Little-endian模式CPU内存中的存放方式�Q�假设从地址0x4000开始存放）为：

内存地址	存放内容
0x4000	0x78
0x4001	0x56
0x4002	0x34
0x4003	0x12

　　而在Big-endian模式CPU内存中的存放方式则�ؓ�Q?br />

内存地址	存放内容
0x4000	0x12
0x4001	0x34
0x4002	0x56
0x4003	0x78

　　联合体union的存��N��序是所有成员都从低地址开始存放，面试者的解答利用该特性，��L��地获得了CPU对内存采用Little-endian�q�是Big-endian模式��d��。如果谁能当场给��个解�{�，那简直就是一个天才的�E�序员�?br />
　　试题2�Q�写一个函数返�?+2+3+�?n的��|��假定�l�果不会��过长整型变量的范围�Q?

　　解答�Q?br />

int Sum( int n )
{
　return ( (long)1 + n) * n / 2;　　//或return (1l + n) * n / 2;
}

　　剖析�Q?br />　
　　对于�q�个题，只能��_��也许最��单的�{�案��是最好的�{�案。下面的解答�Q�或者基于下面的解答思�\��M��化，不管怎么“折�䏀�，其效率也不可能与直接return ( 1 l + n ) * n / 2相比�Q?

int Sum( int n )
{
　long sum = 0;
　for( int i=1; i<=n; i++ )
　{
　　sum += i;
　}
　return sum;
}

　　所以程序员们需要敏感地��数学等知识用在�E�序设计中�?

��力力力 2006-07-27 14:08 发表评论

c 语言隄��分析整理 (�?

��力力力 — Tue, 18 Jul 2006 15:29:00 GMT

�q�篇文章主要是介�l�一些在复习C语言的过�E�中�W�者个��为比较重点的地方�Q�较好的掌握�q�些重点会��对C的运用更加得心应手。此外会包括一些细节、易错的地方。涉及的主要内容包括�Q�变量的作用域和存储�c�d��、函数、数�l�、字�W�串、指针、文件、链表等。一些最基本的概念在此就不多作解释了�Q�仅希望能有只言片语�l�同是C语言初学者的学习和上��E�提供一点点的帮助�?br />

变量作用域和存储�c�d��Q?/strong>

了解了基本的变量�c�d��后，我们要进一步了解它的存储类别和变量作用域问题�?/p>

c 语言隄��分析整理
原创�Q�imy	2003�q?�?0�?

变量�c�d��	子类�?/td>
局部变�?/td>	静态变量（��d��函数�Q�变量��g��保留�Q?/td>
	自动变量
	寄存器变�?/td>
全局变量	静态变量（只能在本文�g中用�Q?/td>
全局变量	非静态变量（允许其他文�g使用�Q?/td>

换一个角�?/p>

变量�c�d��	子类�?/td>
静态存储变�?/font>	静态局部变量（函数�Q?/font>
	静态全局变量�Q�本文�g�Q?/font>
	非静态全局/外部变量�Q�其他文件引用）
动态存储变�?/td>	自动变量
	寄存器变�?/td>
	形式参数

extern型的存储变量在处理多文�g问题时常能用刎ͼ�在一个文件中定义extern型的变量卌��明这个变量用的是其他文�g的。顺便说一下，�W�者在做课设时遇到out of memory的错误，于是�Ҏ��做多文�g�Q�再把它include�q�来�Q�注意自己写�?.h要用“”不�?lt;>�Q�，能�v��C��定的效用。static型的在读�E�序写结果的试题中是个考点。多数时候整个程序会出现多个定义的变量在不同的函��C��Q�考查在不同位�|�同一变量的值是多少。主要是遵��@一个原则，只要本函数内没有定义的变量就用全局变量�Q�而不是main里的�Q�，全局变量和局部变量重名时局部变量�v作用�Q�当然还要注意静态与自动变量的区别�?

函数�Q?/strong>

对于函数最基本的理解是从那个叫main的单词开始的�Q�一开始��M��觉得把语句一�q�写在main里不是挺好的么，��Z��么偏择出厅R��其实这是因为对函数�q�不够熟�l�，否则函数的运用会�l�我们编�E�带来极大的便利。我们要知道函数的返回值类型，参数的类型，以及调用函数时的形式。事先的函数说明也能起到一个提醒的好作用。所谓�Ş参和实参�Q�即在调用函数时写在括号里的��是实参�Q�函数本�w�用的就是�Ş参，在画��程图时用��^行四边�Ş表示传参�?/p>

函数的另一个应用例子就是递归了，�W�者开始比较头疼的问题�Q�反应��L��比较�q�钝�Q�按照老师的方法，把递归的过�E�耐心准确的逐��d��来，学习的效果还是比较好的，会觉得这�U�递归的运用是挺��y的，事实上，著名的八皇后、汉诺塔�{�问题都用到了递归�?/p>

例子�Q?br />long fun(int n)
{
long s;
if(n==1||n==2) s=2;
else s=n-fun(n-1);
return s;
}
main()
{
printf("%ld",fun(4));
}

数组�Q?/strong>

分�ؓ一�l�数�l�和多维数组�Q�其存储方式��Mؓ表格的话��׃��一目了�Ӟ��其实��是把相同类型的变量有序的放在一赗��因此，在处理比较多的数据时�Q�这也是大多数的情况�Q�数�l�的应用范围是非常广的�?/p>

具体的实际应用不便�D例，而且�l�大多数是与指针相结合的�Q�笔者个��为学习数�l�在更大�E�度上是为学习指针做一个铺垫。作为基��的基��要明白几�U�基本操作：��x��l�赋倹{��打印、排序（冒��排序法和选择排序法）、查找。这些都不可避免的用到��@环，如果觉得反应不过来，可以先一点点的把循环展开�Q�就会越来越熟悉�Q�以后自��q��写一个功能的时候就会先扑և�内在规律�Q�较好的�q�用了。另外数�l�做参数�Ӟ��一�l�的[]里可以是�I�的�Q�二�l�的�W�一个[]里可以是�I�的但是�W�二个[]中必��规定大��?/p>

冒��法排序函敎ͼ�
void bubble(inta[],int n)
{
int i,j,k;
for(i=1,i   for(j=0;j<n-i-1;j++)
   if(a[j]>a[j+1])
    {
k=a[j];
       a[j]=a[j+1];
       a[j+1]=k;
       }
}

选择法排序函敎ͼ�
void sort(inta[],int n)
{
int i,j,k,t;
for(i=0,i<n-1;i++)
   {
   k=i;
   for(j=i+1;j      if(a[k]k=j;
      if(k!=i)
         {
         t=a[i];
         a[i]=a[k];
         a[k]=t;
         }
   }
}

折半查找函数�Q�原数组有序�Q�：
void search(inta[],int n,int x)
{
int left=0,right=n-1,mid,flag=0;
while((flag==0)&&(left<=right))
   {
   mid=(left+right)/2;
   if(x==a[mid])
      {
      printf("%d%d",x,mid);
      flag =1;
      }
      elseif(xright=mid-1;
                   elseleft=mid+1;
   }
}

相关常用的算法还�?strong>判断回文�Q�求阶乘�Q�Fibanacci数列�Q��Q意进制�{换，杨辉三角形计��?/strong>�{�等�?/strong>

字符�Ԍ��

字符串其实就是一个数�l�（指针�Q�，在scanf的输入列中是不需要在前面加�?amp;”符��L��Q�因为字�W�数�l�名本��n即代表地址。值得注意的是字符串末��‘\0’，如果没有的话�Q�字�W�串很有可能会不正常的打印。另外就是字�W�串的定义和赋值问题了�Q�笔者有一�ơ的比较�l�合的上��Z��业就是字�W�串打印老是��q��Q�上上下下找了一圈问题，最后发现是因�ؓ

char *name;

而不�?/p>

char name[10];

前者没有说明指向哪儿，更没有确定大��，��D��了�ؕ码的错误�Q�印象挺深刻的�?

另外�Q�字�W�串的赋��g��是需要注意的�Q�如果是用字�W�指针的话，既可以定义的时候赋初��|��?/p>

char *a="Abcdefg";

也可以在赋��D��句中赋��|��?/p>

char *a;
a="Abcdefg";

但如果是用字�W�数�l�的话，��只能在定义时整体赋初��|��即char a[5]={"abcd"};而不能在赋��D��句中整体赋倹{�?

常用字符串函数列表如下，要会自己实现�Q?/p>

函数作用	函数调用形式	备注
字符串拷贝函�?/td>	strcpy(char,char )	后者拷贝到前�?/td>
字符串追加函�?/td>	strcat(char,char )	后者追加到前者后�Q�返回前者，因此前者空间要��_��?/td>
字符串比较函�?/td>	strcmp(char,char )	前者等于、小于、大于后者时�Q�返�?、正倹{��负倹{��注意，不是比较长度�Q�是比较字符ASCII码的大小�Q�可用于按姓名字母排序等�?/td>
字符串长�?/td>	strlen(char *)	�q�回字符串的长度�Q�不包括'\0'.转义字符��一个字�W��?/td>
字符串型->整型	atoi(char *)
整型->字符串型	itoa(int,char *,int)	做课设时挺有用的
整型->字符串型	sprintf(char *,格式化输入）	赋给字符�Ԍ��而不打印出来。课设时用也比较方便

注：对字�W�串是不允许�?=或！=的运��的�Q�只能用字符串比较函�?/p>

指针�Q?/strong>

指针可以说是C语言中最关键的地方了�Q�其实这个“指针”的名字对于�q�个概念的理解是十分形象的。首先要知道�Q�指针变量的��|��x��针变量中存放的��|��是指针（卛_��址�Q�。指针变量定义�Ş式中�Q�基本类�?*指针变量�?中的�?”代表的是这是一个指向该基本�c�d��的指针变量，而不是内容的意思。在以后使用的时候，�?ptr=a�Ӟ��?”才表示ptr所指向的地址里放的内�Ҏ��a�?/p>

指针比较典型又简单的一应用例子是两��C��换，看下面的�E�序�Q?/p>

swap(intc,intd)
{
int t;
t=c;
c=d;
d=t;
}
main()
{
int a=2,b=3;
swap(a,b);
printf(�?d,%d�?a,b);
}

�q�是不能实现a和b的数��g��换的�Q�实际上只是形参在这个函��C��换来换去�Q�对实参没什么媄响。现在，用指针类型的数据做�ؓ参数的话�Q�更改如下：

swap(#3333FF *p1,int *p2)
{
int t;
t=*p1;
*p1=*p2;
*p2=t;
}
main()
{
int a=2,b=3;
int *ptr1,*ptr2;
ptr1=&a;
ptr2=&b;
swap(prt1,ptr2);
printf(�?d,%d�?a,b);
}

�q�样在swap中就把p1,p2 的内容给换了�Q�即把a�Q�b的��g��换了�?/p>

指针可以执行增、减�q�算�Q�结�?+�q�算�W�的法则�Q�我们可以看�?

*++s	取指针变量加1以后的内�?/p>
*s++	取指针变量所指内容后s再加1
*(s)++**	指针变量指的内容�?

指针和数�l?/strong>实际上几乎是一��L��Q�数�l�名可以看成是一个常量指针，一�l�数�l�中ptr=&b[0]则下面的表示法是�{��h的：

a[3]�{��h�?(a+3)
ptr[3]�{��h�?(ptr+3)

下面看一个用指针来自己实现atoi�Q�字�W�串�?>整型�Q�函敎ͼ�

int atoi(char *s)
{
int sign=1,m=0;
if(*s=='+'||*s=='-') /*判断是否有符�?/
sign=(*s++=='+')?1:-1;/*用到三目�q�算�W?/
while(*s!='\0') /*�Ҏ��一个字�W�进行操�?/
   {
   m=m*10+(*s-'0');
   s++;/*指向下一个字�W?/
   }
return m*sign;
}

指向多维数组的指针变量也是一个比较广泛的�q�用。例如数�l�a[3][4]�Q�a代表的实际是整个二维数组的首地址�Q�即�W?行的首地址�Q�也��是一个指针变量。而a+1��׃��是简单的在数��g��加上1了，它代表的不是a[0][1]�Q�而是�W?行的首地址�Q?amp;a[1][0]�?/p>

指针变量常用的用途还有把指针作�ؓ参数传递给其他函数�Q�即指向函数的指�?/strong>�?br />看下面的几行代码�Q?/p>

void Input(ST *);
void Output(ST *);
void Bubble(ST *);
void Find(ST *);
void Failure(ST *);
/*函数声明�Q�这五个函数都是以一个指向ST型（事先定义�q�）�l�构的指针变量作为参敎ͼ�无返回倹{�?/

void(*process[5])(ST *)={Input,Output,Bubble,Find,Failure};
/*process被调用时提供5�U�功能不同的函数共选择(指向函数的指针数�l�）*/

printf("\nChoose:\n?");
scanf("%d",&choice);
if(choice>=0&&choice<=4)
(*process[choice])(a); /*调用相应的函数实��C��同功�?;/

��M��Q�指针的应用是非常灵�z�d��q�泛的，不是三言两语能说完的�Q�上面几个小例子只是个引子，实际�~�程中，会逐渐发现�q�用指针所能带来的便利和高效率�?

文�g�Q?/strong>

函数调用形式	说明
fopen("路径","打开方式")	打开文�g
fclose(FILE *)	防止之后被误�?/td>
fgetc(FILE *)	从文件中��d��一个字�W?/td>
fputc(ch,FILE *)	把ch代表的字�W�写入这个文仉��
fgets(FILE *)	从文件中��d��一�?/td>
fputs(FILE *)	把一行写入文件中
fprintf(FILE *,"格式字符�?,输出表列�Q?/td>	把数据写入文�?/td>
fscanf(FILE *,"格式字符�?,输入表列�Q?/td>	从文件中��d��
fwrite�Q�地址�Q�sizeof�Q�）�Q�n�Q�FILE *�Q?/td>	把地址中n个sizeof大的数据写入文�g�?/td>
fread�Q�地址�Q�sizeof�Q�）�Q�n�Q�FILE *�Q?/td>	把文件中n个sizeof大的数据��d��地址�?/td>
rewind�Q�FILE *�Q?/td>	把文件指针拨回到文�g�?/td>
fseek�Q�FILE *�Q�x�Q?/1/2�Q?/td>	�U�d��文�g指针。第二个参数是位�U�量�Q?代表从头�U�，1代表从当前位�\|�移�Q?代表从文件尾�U�R�?/td>
feof(FILE *)	判断是否��C��文�g末尾

文�g打开方式 说明
r 打开只能�ȝ��文�g
w 建立供写入的文�g�Q�如果已存在��抹��d��有数�?/td>
a 打开或徏立一个把数据�q�加到文件尾的文�?/td>
r+ 打开用于更新数据的文�?/td>
w+ 建立用于更新数据的文�Ӟ��如果已存在就抹去原有数据
a+ 打开或徏立用于更新数据的文�g�Q�数据追加到文�g��?/td>
注：以上用于文本文�g的操作，如果是二�q�制文�g��在上述字母后加“b”�?/p>
我们用文件最大的目的��是能让数据保存下来。因此在要用文�g中数据的时候，��是要把数据��d��一个结构（一般保存数据多用结构，便于��理�Q�中去，再对�l�构�q�行操作卛_��。例如，文�gaa.data中存储的�?0个学生的成�W�{�信息，要遍历这些信息，对其�q�行成�W输出、排序、查扄��工作�Ӟ��我们��把�q�些信息先读入到一个结构数�l�中�Q�再对这个数�l�进行操作。如下例�Q?/p>
#include
#include
#define N 30
typedef struct student /*定义储存学生成�W信息的数�l?/
{
char *name;
int chinese;
int maths;
int phy;
int total;
}ST;
main()
{
ST a[N]; /*存储N个学生信息的数组*/
FILE *fp;
void(*process[3])(ST *)={Output,Bubble,Find}; /*实现相关功能的三个函�?/
int choice,i=0;
Show();
printf("\nChoose:\n?");
scanf("%d",&choice);
while(choice>=0&&choice<=2)
   {
   fp=fopen("aa.dat","rb");
   for(i=0;i;i++)
      fread(&a[i],sizeof(ST),1,fp);/*把文件中储存的信息逐个��d��数组中去*/
   fclose(fp);
   (*process[choice])(a); /*前面提到的指向函数的指针�Q�选择操作*/
   printf("\n");
   Show();
   printf("\n?");
   scanf("%d",&choice);
   }
}
void Show()
{
printf("\n****Choices:****\n0.Display the data form\n1.Bubble it according to the total score\n2.Search\n3.Quit!\n");
}
void Output(ST *a) /*��文件中存储的信息逐个输出*/
{
int i,t=0;
printf("Name Chinese Maths Physics Total\n");
for(i=0;i   {
   t=a[i].chinese+a[i].maths+a[i].phy;
   a[i].total=t;
   printf("%4s%8d%8d%8d%8d\n",a[i].name,a[i].chinese,a[i].maths,a[i].phy,a[i].total);
   }
}
void Bubble(ST *a)/*�Ҏ��l�进行排序，�q�输出结�?/
{
int i,pass;
ST m;
for(pass=0;pass;pass++)
   for(i=0;i;i++)
      if(a[i].total         {
         m=a[i]; /*�l�构互换*/
         a[i]=a[i+1];
         a[i+1]=m;
         }
Output(a);
}
void Find(ST *a)
{
int i,t=1;
char m[20];
printf("\nEnter the name you want:");
scanf("%s",m);
for(i=0;i   if(!strcmp(m,a[i].name))/*�Ҏ��姓名匚w��情况输出查找�l�果*/
   {
   printf("\nThe result is:\n%s, Chinese:%d, Maths:%d,     Physics:%d,Total:%d\n",m,a[i].chinese,a[i].maths,a[i].phy,a[i].total);
   t=0;
   }
if(t)
   printf("\nThe name is not in the list!\n");
}
链表�Q?/strong>
链表是C语言中另外一个难炏V��牵扯到�l�点、动态分配空间等�{�。用�l�构作�ؓ链表的结�Ҏ��非常适合的，例如�Q?/p>
struct node
{
int data;
struct node *next;
};
其中next是指向自�w�所在结构类型的指针�Q�这样就可以把一个个�l�点相连�Q�构成链表�?/p>
链表�l�构的一大优势就是动态分配存储，不会像数�l�一样必��d��定义时确定大��，造成不必要的��费。用malloc和free函数卛_��实现开辟和释放存储单元。其中，malloc的参数多用sizeof�q�算�W�计��得到�?/p>
链表的基本操作有�Q?strong>正、反向徏立链表；输出链表�Q�删除链表中�l�点�Q�在链表中插入结�?/strong>�{�等�Q�都是要熟练掌握的，初学者通过��d��的方式能比较形象地理解徏立、插入等实现的过�E��?/p>
typedef struct node
{
char data;
struct node *next;
}NODE; /*�l�点*/

正向建立链表�Q?br />NODE *create()
{
char ch='a';
NODE *p,*h=NULL,*q=NULL;
while(ch<'z')
   {
   p=(NODE *)malloc(sizeof(NODE)); /*强制�c�d��转换为指�?/
   p->data=ch;
   if(h==NULL) h=p;
      elseq->next=p;
   ch++;
   q=p;
   }
q->next=NULL; /*链表�l�束*/
return h;
}
逆向建立�Q?/p>
NODE *create()
{
char ch='a';
NODE *p,*h=NULL;
while(ch<='z')
   {
   p=(NODE *)malloc(sizeof(NODE));
   p->data=ch;
   p->next=h; /*不断地把head往前挪*/
   h=p;
   ch++;
   }
return h;
}
用递归实现链表逆序输出�Q?/p>
void output(NODE *h)
{
if(h!=NULL)
   {
   output(h->next);
   printf("%c",h->data);
   }
}
插入�l�点�Q�已有升序的链表�Q�：
NODE *insert(NODE *h,int x)
{
NODE *new,*front,*current=h;
while(current!=NULL&&(current->data/*查找插入的位�|?/
   {
   front=current;
   current=current->next;
   }
new=(NODE *)malloc(sizeof(NODE));
new->data=x;
new->next=current;
if(current==h) /*判断是否是要插在表头*/
   h=new;
else front->next=new;
return h;
}
删除�l�点�Q?/p>
NODE *delete(NODE *h,int x)
{
NODE *q,*p=h;
while(p!=NULL&&(p->data!=x))
   {
   q=p;
   p=p->next;
   }
if(p->data==x) /*扑ֈ�了要删的�l�点*/
   {
   if(p==h) /*判断是否要删表头*/
   h=h->next;
      elseq->next=p->next;
   free(p); /*释放掉已删掉的结�?/
   }
return h;
}
�l�常有链表相关的�E�序填空题，做这��L��题要注意看下面提到的变量是否定义了，用到的变量是否赋初��g��Q�是否有�l�分配空间的没有分配�I�间�Q�最后看看返回值是否正��?/p>
�W�者水�q�x��限，隑օ�有疏漏、错误的地方�Q�浅显之处，�q�望指正见谅。上�q�内容仅是个提示作用�Q��ƈ不包括C语言的全部内宏V�?

��力力力 2006-07-18 23:29 发表评论

链表3

��力力力 — Mon, 17 Jul 2006 14:56:00 GMT

链表的运��?02)

发表日期�Q?003�q?�?日    作者：C语言之家搜集整理  已经�?462位读者读�q�此�?/td>

3.链表节点的插�?br />4.链表节点的删�?/font>

3.链表节点的插�?/font>
解：
    1) 首先声明一个新节点供输入要插入节点的内�?br />    2) ��q��戯��入一个节点内�?Key)�Q�表�C�欲插入在哪一个节点之�?br />    3) 持箋往下一个节点，直到节点内容Key或节�Ҏ��针�ؓNULL为止(��x��不到该节�?
    4) 如果该节点不存在�Q�则插入在节点前
        New->Next=Head
        Head=New
    5) 如果扑ֈ�该节点，�?br />        New->Next=Pointer->Next
        Pointer->Next=New
*�E�序代码如下�Q?br />#include
#include
#define Max 10
struct List            /*节点�l�构声明*/
{
    int Number;
    int Total;
    struct List *Next;
};
typedef struct List Node;
typedef Node *Link;
int Data[2][Max]={1,3,5,7,2,4,6,8,9,0,15,35,10,67,25,65,38,70,30,20};
/*插入节点至链表内*/
Link Insert_List(Link Head,Link New,int Key)
{
    Link Pointer;        /*声明节点*/
    Pointer=Head;        /*Pointer指针设�ؓ首节�?/
    while(1)
    {
        if(Pointer==NULL)    /*插入在首节点�?/
        {
            New->Next=Head;
            Head=New;
            break;
        }
        if(Pointer->Number==Key)    /*插入在链表中间或��*/
        {
            New->Next=Pointer->Next;
            Pointer->Next=New;
            break;
        }
        Pointer=Pointer->Next;    /*指向下一个节�?/
    }
    return Head;
}
/*输出链表数据*/
void Print_List(Link Head)
{
    Link Pointer;        /*节点声明*/
    Pointer=Head;        /*Pointer指针设�ؓ首节�?/
    while(Pointer!=NULL)    /*当节点�ؓNULL�l�束循环*/
    {
        printf("[%d,%d]",Pointer->Number,Pointer->Total);
        Pointer=Pointer->Next;    /*指向下一个节�?/
    }
    printf("\n");
}
/*释放链表*/
void Free_List(Link Head)
{
    Link Pointer;        /*节点声明*/
    while(Head!=NULL)    /*当节点�ؓNULL�l�束循环*/
    {
        Pointer=Head;
        Head=Head->Next;
        free(Pointer);
    }
}
/*建立链表*/
Link Create_List(Link Head)
{
    Link New;        /*节点声明*/
    Link Pointer;    /*节点声明*/
    int i;
    Head=(Link)malloc(sizeof(Node));    /*分配内存*/
    if(Head==NULL)
        printf("Memory allocate Failure!\n");    /*内存分配��p�|*/
    else
    {
        Head->Number=Data[0][0];        /*定义首节�Ҏ��据编�?/
        Head->Total=Data[1][0];
        Head->Next=NULL;
        Pointer=Head;        /*Pointer指针设�ؓ首节�?/
        for(i=1;i        {
            New=(Link)malloc(sizeof(Node));    /*分配内存*/
            New->Number=Data[0][i];
            New->Total=Data[1][i];
            New->Next=NULL;
            Pointer->Next=New;        /*��新节点串连在原列表��*/
            Pointer=New;            /*列表��节点为新节点*/
        }
    }
    return Head;
}
/*�ȝ��?/
void main()
{
    Link Head;        /*节点声明*/
    Link New;
    int Key;
    Head=Create_List(Head);    /*建立链表*/
    if(Head!=NULL)
    {
        Print_List(Head);
        while(1)
        {
            printf("Input 0 to Exit\n");    /*数据输入提示*/
            New=(Link)malloc(sizeof(Node));    /*分配内存*/
            printf("Please input Data number:");
            scanf("%d",&New->Number);
            if(New->Number==0)        /*输入0时结束��@�?/
                break;
            printf("Please input the data total:");
            scanf("%d",&New->Total);
            printf("Please input the data number for Insert:");
            scanf("%d",&Key);
            Head=Insert_List(Head,New,Key);    /*插入节点*/
            Print_List(Head);                /*输出链表数据*/
        }
        Free_List(Head);        /*释放链表*/
    }
}
*�E�序�q�行�l�果如下�Q?br />
screen.width-333)this.width=screen.width-333" />
------------------------------------------------------------------

4.链表节点的删�?/font>
解：
    持箋往下一个节�Ҏ��找要删除的节点，直到节点内容扑ֈ�或节�Ҏ��针�ؓNULL(��x��不到该节�?�?br />    在删除时�Q�必��记录前一个节点的位置(Back)
    如果该节点不存在�Q�输��Z��个节点不存在的提�C?br />    如果该节点存在，且是首节点：
        Head=Pointer->Next
        free(Pointer)
    如果该节点存在，但不是首节点(即链表内节点或尾端节�?�Q�则�Q?br />        Back->Next=Pointer->Next
        free(Pointer)
*�E�序代码如下�Q?br />#include
#include
#define Max 10
struct List            /*节点�l�构声明 */
{
    int Number;
    int Total;
    struct List *Next;
};
typedef struct List Node;
typedef Node *Link;
int Data[2][Max]={1,3,5,7,2,4,6,8,9,10,15,35,10,67,25,65,38,70,30,20};
/*删除链表内节�?/
Link Delete_List(Link Head,int Key)
{
    Link Pointer;        /*节点声明*/
    Link Back;
    Pointer=Head;        /*Pointer 指针设�ؓ首节�?/
    while(1)
    {
        if(Pointer->Next==NULL)
        {
            printf("Not Found!\n");
            break;
        }
        if(Head->Number==Key)        /*删除首节�?/
        {
            Head=Pointer->Next;
            free(Pointer);
            break;
        }
        Back=Pointer;
        Pointer=Pointer->Next;    /*指向下一个节�?/
        if(Pointer->Number==Key)    /*插入在链表中间或��*/
        {
            Back->Next=Pointer->Next;
            free(Pointer);
            break;
        }
    }
    return Head;
}
/*输出链表数据*/
void Print_List(Link Head)
{
    Link Pointer;        /*节点声明*/
    Pointer=Head;        /*Pointer指针设�ؓ首节�?/
    while(Pointer!=NULL)    /*当节点�ؓNULL�l�束循环*/
    {
        printf("[%d,%d]",Pointer->Number,Pointer->Total);
        Pointer=Pointer->Next;    /*指向下一个节�?/
    }
    printf("\n");
}
/*释放链表*/
void Free_List(Link Head)
{
    Link Pointer;        /*节点声明*/
    while(Head!=NULL)    /*当节点�ؓNULL�l�束循环*/
    {
        Pointer=Head;
        Head=Head->Next;        /*指向下一个节�?/
        free(Pointer);
    }
}
/*建立链表*/
Link Create_List(Link Head)
{
    Link New;        /*节点声明*/
    Link Pointer;
    int i;
    Head=(Link)malloc(sizeof(Node));        /*分本内存*/
    if(Head==NULL)
        printf("Memory allocate Failure!\n");    /*内存分配��p�|*/
    else
    {
        Head->Number=Data[0][0];        /*定义首节�Ҏ��据编�?/
        Head->Total=Data[1][0];
        Head->Next=NULL;
        Pointer=Head;        /*Pointer指针设�ؓ首节�?/
        for(i=1;i        {
            New=(Link)malloc(sizeof(Node));        /*分配内存*/
            New->Number=Data[0][i];
            New->Total=Data[1][i];
            New->Next=NULL;
            Pointer->Next=New;        /*��新节点串连在原列表��*/
            Pointer=New;            /*列表��节点为新节点*/
        }
    }
    return Head;
}
/*�ȝ��?/
void main()
{
    Link Head=NULL;        /*节点声明*/
    int Key;
    Head=Create_List(Head);        /*建立链表*/
    if(Head!=NULL)
    {
        Print_List(Head);
        while(1)
        {
            printf("Input 0 to exit\n");    /*数据输入提示*/
            printf("Please input the data number for Delete:");
            scanf("%d",&Key);
            if(Key==0)        /*时结束��@�?/
                break;
            Head=Delete_List(Head,Key);    /*删除节点*/
            Print_List(Head);              /*输出链表*/
        }
        Free_List(Head);        /*释放链表*/
    }
}

*�E�序�q�行�l�果如下�Q?/font>
screen.width-333)this.width=screen.width-333" />


��力力力 2006-07-17 22:56 发表评论

链表2

��力力力 — Mon, 17 Jul 2006 14:54:00 GMT
2.设计一个查��N��表中的数据的�E�序
解：
    单链表中的数据查找，只能采用�U�性查找法往下一个节�Ҏ��找。采用线性查找法查找链表中的数据时与数组不同的是�Q�原来数�l�是用递增数组索引来查找数据，在链表中是往下一个节�Ҏ��找�?br />�E�序代码如下�Q?br />#include
#include
#define Max 10
struct List        /*�l�节点结构声�?/
{
    int Number;
    int Total;
    struct List *Next;
};
typedef struct List Node;
typedef Node *Link;
int Data[2][Max]=              /*初始化数�?/
        {3,9,25,5,7,26,65,80,2,6,1050,3850,1000,5670,2250,9650,2380,
            1700,3000,2000};
int SearchTime=0;        /*查找�ơ数*/
/*链表查找*/
int List_Search(int Key,Link Head)
{
    Link Pointer;
    Pointer=Head;        /*Pointer指针设�ؓ首节�?/
    while(Pointer!=NULL)    /*当节点�ؓNULL�l�束循环*/
    {
        SearchTime++;
        if(Pointer->Number==Key)
        {
            printf("Data Number: %d\n",Pointer->Number);
            printf("Data Total: %d\n",Pointer->Total);
            return 1;
        }
        Pointer=Pointer->Next;      /*指向下一个节�?/
    }
    return 0;
}
/*释放链表*/
void Free_List(Link Head)
{
    Link Pointer;        /*节点声明*/
    while(Head!=NULL)    /*当节点�ؓNULL�l�束循环*/
    {
        Pointer=Head;
        Head=Head->Next;    /*指向下一个节�?/
        free(Pointer);
    }
}
/*建立链表*/
Link Create_List(Link Head)
{
    Link New;        /*节点声明*/
    Link Pointer;    /*节点声明*/
    int i;
    Head=(Link)malloc(sizeof(Node));    /*分配内存*/
    if(Head==NULL)
        printf("Memory allocate Failure!\n");    /*内存分配��p�|*/
    else
    {
        Head->Number=Data[0][0];        /*定义首节�Ҏ��据编�?/
        Head->Total=Data[1][0];
        Head->Next=NULL;
        Pointer=Head;            /*Pointer指针设�ؓ首节�?/
        for(i=1;i        {
            New=(Link)malloc(sizeof(Node));    /*分配内存*/
            New->Number=Data[0][i];
            New->Total=Data[1][i];
            New->Next=NULL;
            Pointer->Next=New;        /*��新节点串连在原列表��*/
            Pointer=New;              /*列表��节点为新节点*/
        }
    }
    return Head;
}
/*�ȝ��?/
void main()
{
    Link Head=NULL;        /*节点声明*/
    int Num;          /*�Ʋ查找数据编�?/
    Head=Create_List(Head);    /*建立链表*/
    if(Head!=NULL)
    {
        printf("Please input the data number:");
        scanf("%d",&Num);
        if(List_Search(Num,Head))
            printf("Search Time=%d\n",SearchTime);
        else
            printf("Not Found!\n");
        Free_List(Head);        /*释放链表*/
    }
}
*�q�行�l�果如下�Q?br />
screen.width-333)this.width=screen.width-333" />

��力力力 2006-07-17 22:54 发表评论

链表

��力力力 — Mon, 17 Jul 2006 14:53:00 GMT

链表的运��?01)

发表日期�Q?003�q?�?日    作者：C语言之家搜集整理  已经�?901位读者读�q�此�?/td>

1.设计一个程序将输入的数据徏立成链表、输出链表数据�ƈ在程序结束后释放�?br />2.设计一个查��N��表中的数据的�E�序

1.设计一个程序将输入的数据徏立成链表、输出链表数据�ƈ在程序结束后释放�?br />解：
    1)链表的徏立：先声明一个首节点Head�Q��ƈ��Head->Next设�ؓNULL。每输入一个数据就声明一个新节点New�Q�把New->Next设�ؓNULL�Q��ƈ且链接到之前列表的尾端�?br />    2)链表数据的输出：先将Pointer节点的指针指向第一个节点，��Pointer节点(即第一个节�?的数据输出。然后再��Pointer节点的指针指向Pointer指针的的指针(即下一节点)�Q�将pointer节点(即第一节点)的数据输出。重复执行此步聚直到Pointer指针指向NULL为止�?br />    3)链表的释放：先将Pointer节点的指针指向第一个节点，然后再将首节点设为首节点的指�?即下一节点)。将Pointer节点(即第一节点)释放。重复执行此步聚直到首节点的指针指向NULL为止�?br />�E�序代码如下�Q?br />#include
#include
#define Max 10
struct List             /*节点�l�构声明*/
{
    int Number;
    char Name[Max];
    struct List *Next;
};
typedef struct List Node;
typedef Node *Link;
/*释放链表*/
void Free_List(Link Head)
{
    Link Pointer;      /*节点声明*/
    while(Head!=NULL)      /*当节点�ؓNULL�Q�结束��@�?/
    {
        Pointer=Head;
        Head=Head->Next;   /*指向下一个节�?/
        free(Pointer);
    }
}
/*输出链表*/
void Print_List(Link Head)
{
    Link Pointer;          /*节点声明*/
    Pointer=Head;          /*Pointer指针设�ؓ首节�?/
    while(Pointer!=NULL)   /*当节点�ؓNULL�l�束循环*/
    {
        printf("##Input Data##\n");
        printf("Data Number: %d\n",Pointer->Number);
        printf("Data Name: %s\n",Pointer->Name);
        Pointer=Pointer->Next;     /*指向下一个节�?/
    }
}
/*建立链表*/
Link Create_List(Link Head)
{
    int DataNum;         /*数据�~�号*/
    char DataName[Max];        /*数据名称*/
    Link New;            /*节点声明*/
    Link Pointer;        /*节点声明*/
    int i;
    Head=(Link)malloc(sizeof(Node));     /*分配内存*/
    if(Head==NULL)
        printf("Memory allocate Failure!\n");    /*内存分配夫��|*/
    else
    {
        DataNum=1;      /*初始数据�~�号*/
        printf("Please input the data name:");
        scanf("%s",DataName);
        Head->Number=DataNum;     /*定义首节�Ҏ��据编�?/
        for(i=0;i<=Max;i++)
            Head->Name[i]=DataName[i];
        Head->Next=NULL;
        Pointer=Head;          /*Pointer指针设�ؓ首节�?/
        while(1)
        {
            DataNum++;         /*数据�~�号递增*/
            New=(Link)malloc(sizeof(Node));     /*分配内存*/
            printf("Please input the data Name:");
            scanf("%s",DataName);
            if(DataName[0]=='0')    /*输入0则结�?/
                break;
            New->Number=DataNum;
            for(i=0;i            {
                New->Name[i]=DataName[i];
            }
            New->Next=NULL;
            Pointer->Next=New;     /*��新节点串连在原列表��*/
            Pointer=New;         /*列表��节点为新节点*/
        }
    }
    return Head;
}
/*�ȝ��?/
void main()
{
    Link Head;       /*节点声明*/
    Head=Create_List(Head);     /*调用建立链表函数*/
    if(Head!=NULL)
    {
        Print_List(Head);      /*调用输出链表数据函数*/
        Free_List(Head);       /*调用释放链表函数*/
    }
}

�q�行�l�果如下�Q?br />
screen.width-333)this.width=screen.width-333" />

��力力力 2006-07-17 22:53 发表评论

��Z��?char** 不能自动转化�?const char** (�?

��力力力 — Thu, 29 Dec 2005 15:00:00 GMT

��Z��?char** 不能自动转化�?const char**

一�ơ偶然的情况下我发现以下代码竟然无法被编译通过�Q�如果你的编译器�Q�比如VC6或VC2003�Q�允许它�~�译通过�Q�我想你首先应该换个�~�译器，比如GCC或VC2005�Q�：
void foo( const char* [] ) { }
int main( void )
{
    char* s[2];
    foo( s );
}
��化成更一般的形式是：
char** p1 = 0;
const char** p2 = p1;
错误是：invalid conversion from `char**' to `const char**'.

lostpencil更加仔细�Q��用C�~�译器给出的是一个警告：
initialization from incompatible pointer type.

随后hpho�l�出了合理的解释�Q�同�?A target=_blank>comp.lang.c++.moderated上的Ulrich Eckhardt也用代码�q�行了说明�?/P>
用代码来说明最直观了：
const char* s = "abc";
int main( void )
{
    char* p0 = 0;
    char** p1 = &p0;
    const char** p2 = p1; // 先假设这一句是合法�?( ��试�Ӟ��可以先强制类型�{化一�?)
    *p2 = s;
    *p0 = 'A'; // 通过p0在修改不应该被修改的s�Q�这昄��和const相违背，其运行结果不可知�?BR>}

看了 **�?惛_��?BR>tekyDec 29, 2005 - Show original item

看完�?明白**讲的��Z��么char** 不能自动转化�?const char**,(原文)但对我媄响最��q��是下面的�?

==================================================================
char *p="abc" 能不能编译通过要看你��用的�~�译器。鉴于大量遗留代码的存在�Q�大部分�~�译器允许其通过�Q�或者给个警告。当�Ӟ��E�序员自己必��M��证绝不去修改其倹{�?

�E�序员不应该在代码中出现*p='A'�q�样的语句。这是当初约定好了的�Q�编译器允许char *p="abc"通过�Q�而程序员保证不去修改它�?
b. *p='A'�~�译时应该允讔R��过�Q�因为单��p��条语句而言�Q�它完全合法�?
c. �q�行�?p='A'能不能通过要看实际的运行环境，包括你��用的操作�pȝ��、编译器、编译器选项 �{�等�Q�一句话�Q�其�q�行�l�果�׃��得你�Q�且不应该由你去兛_��Q�因��U�行为本�w�已�l�违反约定了�?
==================================================================

工作关系�?用CString 和string用的太多�?很少�q�样定义字符�?char *p=“abcde“了
匝一�?�q�不适应,:(,渐渐的回��x��惌��v一些来(�?�q�是太生�?赶快写下�?以后别忘�?

�q�样定义的字�W�串char *p=“abcde�?; char *p1=�?23445667�?

正如上面提到的是不能�?*p='A',�q�行的时候会出错,同样,strcpy(p,p1)也会出错�?

"abcde"字符串可以看做是个常量字�W�串�?是不能被修改�?

但如�?char p[]=“abcde�?�q�样定义,��没有问�?你可以修�?p='A',只要不越界就ok.

�q�且发现�q�样两种定义
char *p=“abcde�?/FONT>

char p[]=“abcde�?

在运行的时�?p指向的地址也不是一��L��,可见char *p=“abcde“还是有�Ҏ��的处�?:),具体怎么处理��׃��知道�?高手��h��?)

随着��试,又发��C��问题,可能是个老问题了�?

int main(int argc, char* argv[])
{
int t[10];
char p1[7]="123456";
const char *p2="1234567890123213123";

int len(0);

//*p1='C'; err

len=strlen(p1);
printf("%d\n",len);

strcpy(p1,p2);   ///??????????

printf("%s\n",p1);

len=strlen(p1);

printf("%d\n",len);
return 0;
}

我定义的�?个字�W�数�l? 但用strcpy把p2拷到p1�?p1是放不下�?但程序却正常执行,warning ,err都没�?�q�行也正�?

输出

6
1234567890123213123
19

应该是��用内存越界了�??怎么会正常运行呢?

��N��对于内存��界的��?�q�气好才崩溃表现出来,�q�气不好��正常运�??

��力力力 2005-12-29 23:00 发表评论

学习~strtok

��力力力 — Sat, 05 Nov 2005 12:39:00 GMT

extern char *GetField(char *ibuf,char *ChrSet,int num)
{
int i=0;
static char tmp[256];
char *pt,*pstr;

pstr=(char *)malloc(strlen(ibuf)+1);
strcpy(pstr,ibuf);
for(i=0,pt=strtok(pstr,ChrSet);pt!=NULL;i++,pt=strtok(NULL,ChrSet))
{
if(i>=num||pt==NULL) break;
}
strcpy(tmp,pt);
free(pstr);
return(tmp);
}

例：
char *pt;
char buf[]="324324324|234324324|23432432432|23432432432|33333";
pt=GetField(buf,"|",3);

static void addArray(char *buff, char array[][MQ_ARRAY_LEN])
{


    int index = 0;
    int i=0;

    char *pt,*pstr;
    char * ChrSet= ",";

    pstr=(char *)malloc(strlen(buff)+1);
    pstr = strcpy( pstr, buff);
    for(i=0,pt=strtok(pstr,ChrSet); pt!=NULL; i++, pt=strtok(NULL,ChrSet))
    {
        if(pt==NULL) break;
      // printf("dealing ... %s\n", pt);
        strcpy(array[index],pt);
        index++;
    }
    free(pstr);

}

��力力力 2005-11-05 20:39 发表评论

C语言嵌入式系�l�编�E�修��g��?性能优化

��力力力 — Wed, 21 Sep 2005 09:35:00 GMT

C语言嵌入式系�l�编�E�修��g��?性能优化

作�?宋宝�? 更新日期:2005-07-22

使用宏定�?/b>

　　在C语言中，宏是产生内嵌代码的唯一�Ҏ��。对于嵌入式�pȝ��而言�Q��ؓ了能辑ֈ�性能要求�Q�宏是一�U�很好的代替函数的方法�?br>
　　写一�?标准"宏MIN �Q�这个宏输入两个参数�q�返回较��的一个：

　　错误做法�Q?br>

#define MIN(A,B) 　( A <= B ? A : B )

　　正确做法�Q?br>

#define MIN(A,B) �Q�（A�Q?lt;= (B) ? (A) : (B) )

　　对于宏，我们需要知道三点：

　　(1)宏定�?�?函数�Q?br>
　　(2)宏定义不是函敎ͼ�因而需要括上所�?参数"�Q?br>
　　(3)宏定义可能��生副作用�?br>
　　下面的代码：

least = MIN(*p++, b);

　　��被替换为：

( (*p++) <= (b) ?(*p++):(b) )

　　发生的事情无法预料�?

　　因而不要给宏定义传入有副作用的"参数"�?br>
　　使用寄存器变�?/b>

　　当对一个变量频�J�被��d��Ӟ��需要反复访问内存，从而花费大量的存取旉��。�ؓ此，C语言提供了一�U�变量，卛_��存器变量。这�U�变量存攑֜�CPU的寄存器中，使用�Ӟ��不需要访问内存，而直接从寄存器中��d��Q�从而提高效率。寄存器变量的说明符是register。对于��@环次数较多的循环控制变量及��@环体内反复�� 用的变量均可定义为寄存器变量�Q�而��@环计数是应用寄存器变量的最好候选者�?br>
　　(1) 只有局部自动变量和形参才可以定义�ؓ寄存器变量。因为寄存器变量属于动态存储方式，凡需要采用静态存储方式的量都不能定义为寄存器变量�Q�包括：模块间全局变量、模块内全局变量、局部static变量�Q?br>
　　(2) register是一�?��"型关键字�Q�意指程序徏议该变量攑֜�寄存器中�Q�但最�l�该变量可能因�ؓ条�g不满��_ƈ未成为寄存器变量�Q�而是被放在了存储器中�Q�但�~�译器中�q�不报错�Q�在C++语言中有另一�?��"型关键字�Q�inline�Q��?br>
　　下面是一个采用寄存器变量的例子：

/* �?+2+3+�?+n的�?*/
WORD Addition(BYTE n)
{
　register i,s=0;
　for(i=1;i<=n;i++)
　{
　　s=s+i;
　}
　return s;
}

　　本程序��@环n�ơ，i和s都被频繁使用�Q�因此可定义为寄存器变量�?br>
　　内嵌汇编

　　�E�序中对旉��要求苛刻的部分可以用内嵌汇编来重写，以带来速度上的显著提高。但是，开发和��试汇编代码是一件辛苦的工作�Q�它��花�Ҏ��长的旉��Q�因而要慎重选择要用汇编的部分�?br>
　　在程序中�Q�存在一�?0-20原则�Q�即20%的程序消耗了80%的运行时��_��因而我们要改进效率�Q�最主要是考虑改进�?0%的代码�?br>
　　嵌入式C�E�序中主要��用在�U�汇�~�，卛_��C�E�序中直接插入_asm{ }内嵌汇编语句�Q?br>

/* 把两个输入参数的值相加，�l�果存放到另外一个全局变量�?*/
int result;
void Add(long a, long *b)
{
　_asm
　{
　　MOV AX, a
　　MOV BX, b
　　ADD AX, [BX]
　　MOV result, AX
　}
}

　　利用��g�Ҏ�?/b>

　　首先要明白CPU对各�U�存储器的访问速度�Q�基本上是：

CPU内部RAM　>　外部同步RAM　>　外部异步RAM　>　FLASH/ROM

　　对于�E�序代码�Q�已�l�被烧录在FLASH或ROM中，我们可以让CPU直接从其中读取代码执行，但通常�q�不是一个好办法�Q�我们最好在�pȝ��启动后将FLASH或ROM中的目标代码拯��入RAM中后再执行以提高取指令速度�Q?br>
　　对于UART�{�设备，其内部有一定容量的接收BUFFER�Q�我们应��量在BUFFER被占满后再向CPU提出中断。例如计��机�l�端在向目标机通过RS-232传递数据时�Q�不宜设�|�UART只接收到一个BYTE��向CPU提中断，从而无谓浪费中断处理时��_��

　　如果�Ҏ��讑֤�能采取DMA方式��d��Q�就采用DMA��d��Q�DMA��d��方式在读取目标中包含的存储信息较大时效率较高�Q�其数据传输的基本单位是块，而所传输的数据是从设备直接送入内存的（或者相反）。DMA方式较之中断驱动方式�Q�减��了CPU 对外讄��q�预�Q�进一步提高了CPU与外讄��q�行操作�E�度�?br>
　　�zȝ��位操�?/b>

　　使用C语言的位操作可以减少除法和取模的�q�算。在计算机程序中数据的位是可以操作的最��数据单位，理论上可以用"位运��?来完成所有的�q�算和操作，因而，灉|��的位操作可以有效地提高程序运行的效率。�D例如下：

/* �Ҏ��1 */
int i,j;
i = 879 / 16;
j = 562 % 32;
/* �Ҏ��2 */
int i,j;
i = 879 >> 4;
j = 562 - (562 >> 5 << 5);

　　对于�?的指数次方�ؓ"*"�?/"�?%"因子的数学运��，转化为移位运��?<< >>"通常可以提高��法效率。因��Z��除运��指令周期通常比移位运��大�?br>
　　C语言位运��除了可以提高运��效率外�Q�在嵌入式系�l�的�~�程中，它的另一个最典型的应用，而且十分�q�泛地正在被使用着的是位间的与�Q?amp;�Q�、或 �Q�|�Q�、非�Q�~�Q�操作，�q�跟嵌入式系�l�的�~�程特点有很大关�p�R��我们通常要对��g寄存器进行位讄��Q�譬如，我们通过��AM186ER�?0186处理器的�? 断屏蔽控制寄存器的第�?位设�|��ؓ0�Q�开中断2�Q�，最通用的做法是�Q?br>

#define INT_I2_MASK 0x0040
wTemp = inword(INT_MASK);
outword(INT_MASK, wTemp &~INT_I2_MASK);

　　而将该位讄��?的做法是�Q?br>

#define INT_I2_MASK 0x0040
wTemp = inword(INT_MASK);
outword(INT_MASK, wTemp | INT_I2_MASK);

　　判断该位是否�?的做法是�Q?br>

#define INT_I2_MASK 0x0040
wTemp = inword(INT_MASK);
if(wTemp & INT_I2_MASK)
{
�?/* 该位�? */
}

　　上述�Ҏ��在嵌入式�pȝ��的编�E�中是非常常见的�Q�我们需要牢固掌握�?

　　�ȝ��

　　在性能优化斚w��永远注意80-20准备�Q�不要优化程序中开销不大的那80%�Q�这是劳而无功的�?br>
　　宏定义是C语言中实现类似函数功能而又不具函数调用和返回开销的较好方法，但宏在本质上不是函数�Q�因而要防止宏展开后出��C��可预料的�l�果�Q�对宏的定义�? 使用要慎而处之。很遗憾�Q�标准C至今没有包括C++中inline函数的功能，inline函数兼具无调用开销和安全的优点�?br>
　　使用寄存器变量、内嵌汇�~�和�zȝ��位操作也是提高程序效率的有效�Ҏ��?br>
　　除了�~�程上的技巧外�Q��ؓ提高�pȝ��的运行效率，我们通常也需要最大可能地利用各种��g讑֤�自��n的特�Ҏ��减小其运转开销�Q�例如减��中断次数、利用DMA传输方式�{��?img src ="http://www.tkk7.com/faintbear/aggbug/13658.html" width = "1" height = "1" />

��力力力 2005-09-21 17:35 发表评论

C语言嵌入式系�l�编�E�修��g��?键盘操作

��力力力 — Wed, 21 Sep 2005 09:34:00 GMT

C语言嵌入式系�l�编�E�修��g��?键盘操作

作�?宋宝�? 更新日期:2005-07-22

处理功能�?/b>

　　功能键的问题在于�Q�用��L��面�ƈ非固定的�Q�用户功能键的选择��屏幕画面处于不同的显�C�状态下。例如，�ȝ��面如�?�Q?br>

�? �ȝ��?/div>

　　当用户在讄��XX上按下Enter键之后，画面��切换到了设�|�XX的界面，如图2�Q?br>

�? 切换到设�|�XX画面

　　�E�序如何判断用户处于哪一画面�Q��ƈ在该画面的程序状态下调用对应的功能键处理函数�Q�而且保证良好的结构，是一个值得思考的问题�?br>
　　让我们来看看WIN32�~�程中用到的"�H�口"概念�Q�当消息�Q�message�Q�被发送给不同�H�口的时候，该窗口的消息处理函数�Q�是一个callback�? 敎ͼ�最�l�被调用�Q�而在该窗口的消息处理函数中，又根据消息的�c�d��调用了该�H�口中的对应处理函数。通过�q�种方式�Q�WIN32有效的组�l�了不同的窗口，�q�处�? 不同�H�口情况下的消息�?br>
　　我们从中学习到的��是�Q?br>
　　�Q?�Q�将不同的画面类比�ؓWIN32中不同的�H�口�Q�将�H�口中的各种元素�Q�菜单、按钮等�Q�包含在�H�口之中�Q?br>
　　�Q?�Q�给各个画面提供一个功能键"消息"处理函数�Q�该函数接收按键信息为参敎ͼ�

　　�Q?�Q�在各画面的功能�?消息"处理函数中，判断按键�c�d��和当前焦点元素，�q�调用对应元素的按键处理函数�?br>

/* ��窗口元素、消息处理函数封装在�H�口�?*/
struct windows
{
　BYTE currentFocus;
　ELEMENT element[ELEMENT_NUM];
　void (*messageFun) (BYTE keyValue);
　�?br>};
/* 消息处理函数 */
void messageFunction(BYTE keyValue)
{
　BYTE i = 0;
　/* 获得焦点元素 */
　while ( (element [i].ID!= currentFocus)&& (i < ELEMENT_NUM) )
　{
　　i++;
　}
　/* "消息映射" */
　if(i < ELEMENT_NUM)
　{
　　switch(keyValue)
　　{
　　　case OK:
　　　　element[i].OnOk();
　　　　break;
　　　�?br>　　}
　}
}

　　在窗口的消息处理函数中调用相应元素按键函数的�q�程�c�M��?消息映射"�Q�这是我们从WIN32�~�程中学习到的。编�E�到了一个境界，很多东西都是盔R��的了。其它地方的思想可以拿过来�ؓ我所用，是�ؓ�~�程中的"拿来��M��"�?br>
　　在这个例子中�Q�如果我们还想玩得更大一点，我们可以借鉴MFC中处理MESSAGE_MAP的方法，我们也可以学习MFC定义几个�_�֦�的宏来实�?消息映射"�?br>处理数字�?/b>

　　用户输入数字时是一位一位输入的�Q�每一位的输入都对应着屏幕上的一个显�C�Z��|�（x坐标�Q�y坐标�Q�。此外，�E�序�q�需要记录该位置输入的��|��所以有效组�l�用��h��字输入的最��x��式是定义一个结构体�Q�将坐标和数值捆�l�在一��P��

/* 用户数字输入�l�构�?*/
typedef struct tagInputNum
{
　BYTE byNum; /* 接收用户输入赋�?*/
　BYTE xPos; /* 数字输入在屏�q�上的显�C�Z��|�x坐标 */
　BYTE yPos; /* 数字输入在屏�q�上的显�C�Z��|�y坐标 */
}InputNum, *LPInputNum;

　　那么接收用户输入��可以定义一个结构体数组�Q�用数组中的各位�l�成一个完整的数字�Q?br>

InputNum inputElement[NUM_LENGTH]; /* 接收用户数字输入的数�l?*/
/* 数字按键处理函数 */
extern void onNumKey(BYTE num)
{
if(num==0|| num==1) /* 只接收二�q�制输入 */
{
　/* 在屏�q�上昄��用户输入 */
　DrawText(inputElement[currentElementInputPlace].xPos, inputElement[currentElementInputPlace].yPos, "%1d", num);
　/* ��输入赋值给数组元素 */
　inputElement[currentElementInputPlace].byNum = num;
　/* 焦点及光标右�U?*/
　moveToRight();
}
}

　　��数字每一位输入的坐标和输入值捆�l�后�Q�在数字键处理函��C��可以较有结构的�l�织�E�序�Q��ɽE�序昑־�很紧凑�?br>
　　整理用户输入

　　�l�箋�W?节的例子�Q�在�W?节的onNumKey函数中，只是获取了数字的每一位，因而我们需要将其�{化�ؓ有效数据�Q�譬如要转化为有效的XXX数据�Q�其�Ҏ��是：

/* �?�q�制数据位�{化�ؓ有效数据�Q�XXX */
void convertToXXX()
{
　BYTE i;
　XXX = 0;
　for (i = 0; i < NUM_LENGTH; i++)
　{
　　XXX += inputElement[i].byNum*power(2, NUM_LENGTH - i - 1);
　}
}

　　反之�Q�我们也可能需要在屏幕上显�C�那些有效的数据位，因�ؓ我们也需要能够反向�{化：

/* 从有效数据�{化�ؓ2�q�制数据位：XXX */
void convertFromXXX()
{
　BYTE i;
　XXX = 0;
　for (i = 0; i < NUM_LENGTH; i++)
　{
　　inputElement[i].byNum = XXX / power(2, NUM_LENGTH - i - 1) % 2;
　}
}

　　当然在上面的例子中，因�ؓ数据�?�q�制的，用power函数不是很好的选择�Q�直接用"<< >>"�U�M��操作效率更高�Q�我们仅是�ؓ了说明问题的方便。试惻I��如果用户输入是十�q�制的，power函数或许是唯一的选择了�?br>
　　�ȝ��

　　本篇�l�出了键盘操作所涉及的各个方面：功能键处理、数字键处理及用戯��入整理，基本上提供了一个全套的按键处理�Ҏ��。对于功能键处理�Ҏ��Q�将LCD屏幕与Windows�H�口�q�行�c�L��Q�提��Z��较新颖地解决屏幕、键盘繁杂交互问题的�Ҏ��?br>
　　计算机学的许多知识都��h��盔R��性，因而，不断�q�赶旉��技术而忽略基本功的做法是徒劳无意的。我们最多需�?�_�N�?三种语言�Q�精通，一个在如今的求职简�? 里泛滥成灄��词语�Q�，最��x��档是汇编、C、C++�Q�或JAVA�Q�，很显�Ӟ��如果�?�_�N�?了这三种语言�Q�其它语�a�你应该是可以很快"熟悉"的，否则你就�? �?�_�N�?它们.

��力力力 2005-09-21 17:34 发表评论

C语言嵌入式系�l�编�E�修��g��?屏幕操作

��力力力 — Wed, 21 Sep 2005 09:32:00 GMT

C语言嵌入式系�l�编�E�修��g��?屏幕操作

作�?宋宝�? 更新日期:2005-07-22

汉字处理

　　现在要解决的问题是，嵌入式系�l�中�l�常要��用的�q��是完整的汉字库，往往只是需要提供数量有限的汉字供必要的昄��功能。例如，一个微波炉的LCD上没有必要提供显�C?电子邮�g"的功能；一个提供汉字显�C�功能的�I��的LCD上不需要显�C�Z��?短消�?�Q�诸如此�c�R�? 但是一部手机、小灵通则通常需要包括较完整的汉字库�?br>
　　如果包括的汉字库较完��_��那么�Q�由内码�? ��出汉字字模在库中的偏移是十分简单的�Q�汉字库是按照区位的��序排列的，前一个字节�ؓ该汉字的区号�Q�后一个字节�ؓ该字的位受��每一个区记录94个汉字，�? 号则��字在该区中的位置。因此，汉字在汉字库中的具体位置计算公式为：94*(区号-1)+位号-1。减1是因为数�l�是�?为开始而区号位��h��?为开始的。只需乘上一个汉字字模占用的字节数即可，卻I��(94*(区号-1)+位号-1)*一个汉字字模占用字节数�Q�以16*16炚w��字库��Z��Q�计��公式则为：(94*(区号-1)+(位号-1))*32。汉字库中从该位�|��v�?2字节信息记录了该字的字模信息�?br>
　　对于包含较完整汉字库的系�l�而言�Q�我们可以以上述规则计算字模的位�|�。但是如果仅仅是提供��量汉字呢？譬如几十臛_��百个�Q�最好的做法是：

　　定义宏：

# define EX_FONT_CHAR(value)
# define EX_FONT_UNICODE_VAL(value) (value),
# define EX_FONT_ANSI_VAL(value) (value),

　　定义�l�构体：

typedef struct _wide_unicode_font16x16
{
　WORD value; /* 内码 */
　BYTE data[32]; /* 字模炚w�� */
}Unicode;
#define CHINESE_CHAR_NUM �?/* 汉字数量 */

　　字模的存储用数组�Q?br>

Unicode chinese[CHINESE_CHAR_NUM] =
{
{
EX_FONT_CHAR("�?)
EX_FONT_UNICODE_VAL(0x4e1a)
{0x04, 0x40, 0x04, 0x40, 0x04, 0x40, 0x04, 0x44, 0x44, 0x46, 0x24, 0x4c, 0x24, 0x48, 0x14, 0x50, 0x1c, 0x50, 0x14, 0x60, 0x04, 0x40, 0x04, 0x40, 0x04, 0x44, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00}
},
{
EX_FONT_CHAR("�?)
EX_FONT_UNICODE_VAL(0x4e2d)
{0x01, 0x00, 0x01, 0x00, 0x21, 0x08, 0x3f, 0xfc, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08,
0x3f, 0xf8, 0x21, 0x08, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00}
},
{
EX_FONT_CHAR("�?)
EX_FONT_UNICODE_VAL(0x4e91)
{0x00, 0x00, 0x00, 0x30, 0x3f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xff, 0xfe, 0x03, 0x00, 0x07, 0x00,

0x06, 0x40, 0x0c, 0x20, 0x18, 0x10, 0x31, 0xf8, 0x7f, 0x0c, 0x20, 0x08, 0x00, 0x00}
},
{
EX_FONT_CHAR("�?)
EX_FONT_UNICODE_VAL(0x4ef6)
{0x10, 0x40, 0x1a, 0x40, 0x13, 0x40, 0x32, 0x40, 0x23, 0xfc, 0x64, 0x40, 0xa4, 0x40, 0x28, 0x40, 0x2f, 0xfe,

0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40}
}
}

　　要显�C�特定汉字的时候，只需要从数组中查扑ֆ�码与要求汉字内码相同的即可获得字模。如果前面的汉字在数�l�中以内码大��顺序排列，那么可以以二分查找法更高效的查找到汉字的字模�?br>
　　�q�是一�U�很有效的组�l�小汉字库的�Ҏ��Q�它可以保证�E�序有很好的�l�构�?br>
　　�pȝ��旉��昄��

　　从NVRAM中可以读取系�l�的旉��Q�系�l�一般借助NVRAM产生的秒中断每秒��d��一�ơ当前时间�ƈ在LCD上显�C�。关于时间的昄��Q�有一个效率问题。因�? 旉��有其�Ҏ��性，那就�?0�U�才有一�ơ分钟的变化�Q?0分钟才有一�ơ小时变化，如果我们每次都将��d��的时间在屏幕上完全重新刷��C��ơ，则浪费了大量的系�l? 旉��?br>
　　一个较好的办法是我们在旉��昄��函数中以静态变量分别存储小时、分钟、秒�Q�只有在其内容发生变化的时候才更新其显�C��?br>

extern void DisplayTime(�?
{
　static BYTE byHour,byMinute,bySecond;
　BYTE byNewHour, byNewMinute, byNewSecond;
　byNewHour = GetSysHour();
　byNewMinute = GetSysMinute();
　byNewSecond = GetSysSecond();
　
　if(byNewHour!= byHour)
　{
　　�?/* 昄��时 */
　　byHour = byNewHour;
　}
　if(byNewMinute!= byMinute)
　{
　　�?/* 昄��分钟 */
　　byMinute = byNewMinute;
　}
　if(byNewSecond!= bySecond)
　{
　　�?/* 昄��U�钟 */
　　bySecond = byNewSecond;
　}
}

　　�q�个例子也可以顺便作为C语言中static关键字强大威力的证明。当�Ӟ��在C++语言里，static��h��了更加强大的威力�Q�它使得某些数据和函数脱��?对象"而成�?�c?的一部分�Q�正是它的这一特点�Q�成��׃��软�g的无��C��U�设计�?br>动画昄��

　　动画是无所谓有�Q�无所谓无的，静止的画面走的�\多了�Q�也��成了动甅R��随着旉��的变��_��在屏�q�上昄��不同的静止画面，��x��动画之本质。所以，在一个嵌入式�pȝ��的LCD上欲昄��动画�Q�必��d��助定时器。没有硬件或软�g定时器的世界是无法想像的�Q?br>
　　�Q?�Q?没有定时器，一个操作系�l�将无法�q�行旉��片的轮�{�Q�于是无法进行多��d��的调度，于是便不再成其�ؓ一个多��d��操作�pȝ��Q?br>
　　�Q?�Q?没有定时器，一个多媒体播放软�g��无法运作，因�ؓ它不知道何时应该切换��C��一帧画面；

　　�Q?�Q?没有定时器，一个网�l�协议将无法�q��{�Q�因为其无法��L��何时包传输超时�ƈ重传之，无法在特定的旉��完成特定的�Q务�?br>
　　因此�Q�没有定时器��意味着没有操作�pȝ��、没有网�l�、没有多媒体�Q�这��是怎样的黑暗？所以，合理�q�灵�z�d��使用各种定时器，是对一个��Y件�h的最基本需求！

　　�?0186��Z��芯片的嵌入式�pȝ��中，我们需要借助��g定时器的中断来作��Y件定时器�Q�在中断发生后变更画面的昄��内容。在旉��昄��"xx:xx"中让冒号交替有无�Q�每�ơ秒中断发生后，需调用ShowDot�Q?br>

void ShowDot()
{
　static BOOL bShowDot = TRUE; /* 再一�ơ领略static关键字的威力 */
　if(bShowDot)
　{
　　showChar(�?�?xPos,yPos);
　}
　else
　{
　　showChar(�?�?xPos,yPos);
　}
　bShowDot = ! bShowDot;
}

　　菜单操作

　　无数��Zؓ之绞��脑汁的问题�l�于出现了，在这一节里�Q�我们将看到�Q�在C语言中哪怕用��C��丁点的面向对象思想�Q��Y件结构将会有何等的改观！

　　�W�者曾�l�是个笨蛋，被菜单搞晕了�Q�给��L��一个系�l�：

�? 菜单范例

　　要求以键盘上�?�?�?键切换菜单焦点，当用户在焦点处于某菜单时�Q�若敲击键盘上的OK、CANCEL键则调用该焦点菜单对应之处理函数。我曄��d��地这样做着�Q?br>

/* 按下OK�?*/
void onOkKey()
{
　/* 判断在什么焦点菜单上按下Ok键，调用相应处理函数 */
　Switch(currentFocus)
　{
　　case MENU1:
　　　menu1OnOk();
　　　break;
　　case MENU2:
　　　menu2OnOk();
　　　break;
　　�?br>　}
}
/* 按下Cancel�?*/
void onCancelKey()
{
　/* 判断在什么焦点菜单上按下Cancel键，调用相应处理函数 */
　Switch(currentFocus)
　{
　　case MENU1:
　　　menu1OnCancel();
　　　break;
　　case MENU2:
　　　menu2OnCancel();
　　　break;
　　�?br>　}
}

　　�l�于有一天，我这样做了：

/* ��菜单的属性和操作"��装"在一�?*/
typedef struct tagSysMenu
{
　char *text; /* 菜单的文�?*/
　BYTE xPos; /* 菜单在LCD上的x坐标 */
　BYTE yPos; /* 菜单在LCD上的y坐标 */
　void (*onOkFun)(); /* 在该菜单上按下ok键的处理函数指针 */
　void (*onCancelFun)(); /* 在该菜单上按下cancel键的处理函数指针 */
}SysMenu, *LPSysMenu;

　　当我定义菜单�Ӟ��只需要这��P��

static SysMenu menu[MENU_NUM] =
{
　{
　　"menu1", 0, 48, menu1OnOk, menu1OnCancel
　}
　,
　{
　　" menu2", 7, 48, menu2OnOk, menu2OnCancel
　}
　,
　{
　　" menu3", 7, 48, menu3OnOk, menu3OnCancel
　}
　,
　{
　　" menu4", 7, 48, menu4OnOk, menu4OnCancel
　}
　�?br>};

　　OK键和CANCEL键的处理变成�Q?br>

/* 按下OK�?*/
void onOkKey()
{
　menu[currentFocusMenu].onOkFun();
}
/* 按下Cancel�?*/
void onCancelKey()
{
　menu[currentFocusMenu].onCancelFun();
}

　　�E�序被大大简化了�Q�也开始具有很好的可扩展性！我们仅仅利用了面向对象中的封装思想�Q�就让程序结构清晎ͼ�其结果是几乎可以在无需修改�E�序的情况下在系�l�中��d��更多的菜单，而系�l�的按键处理函数保持不变�?br>
　　面向对象�Q�真��了�Q?br>模拟MessageBox函数

　　MessageBox函数�Q�这个Windows�~�程中的��猛料�Q�不知道是多��入门者第一�ơ用到的函数。还记得我们�W�一�ơ在Windows中利用MessageBox输出 "Hello,World!"对话框时新奇的感觉吗�Q�无法统计，�q�个世界上究竟有多少�E�序员学习Windows�~�程是从MessageBox ("Hello,World!",�?开始的。在我本�U�的学校�Q�广泛流传着一个词汇，叫做"’Hello,World’��E�序�?�Q�意指入门��E�序员，�? ��g��"’Hello,World’��"�q�个说法更搞�W�而�Ş象�?br>

　
�? �l�典的Hello,World!

　　�?�l�出了两�U�永恒经典的Hello,World对话框，一�U�只��h��"��定"�Q�一�U�则包含"��定"�?取消"。是的，MessageBox的确有，而且也应该有两类�Q�这完全是由特定的应用需求决定的�?br>
　　嵌入式系�l�中没有�l�我们提供MessageBox�Q�但是鉴于其功能强大�Q�我们需要模拟之�Q�一个模拟的MessageBox函数为：

/******************************************
/* 函数名称: MessageBox
/* 功能说明: 弹出式对话框,昄��提醒用户的信�?br>/* 参数说明: lpStr --- 提醒用户的字�W�串输出信息
/* TYPE --- 输出格式(ID_OK = 0, ID_OKCANCEL = 1)
/* �q�回�? �q�回对话框接收的键�?只有两种 KEY_OK, KEY_CANCEL
/******************************************
typedef enum TYPE { ID_OK,ID_OKCANCEL }MSG_TYPE;
extern BYTE MessageBox(LPBYTE lpStr, BYTE TYPE)
{
　BYTE keyValue = -1;

　ClearScreen(); /* 清除屏幕 */
　DisplayString(xPos,yPos,lpStr,TRUE); /* 昄��字符�?*/
　/* �Ҏ��对话框类型决定是否显�C�确定、取�?*/
　switch (TYPE)
　{
　　case ID_OK:
　　　DisplayString(13,yPos+High+1, " ��定 ", 0);
　　　break;
　　case ID_OKCANCEL:
　　　DisplayString(8, yPos+High+1, " ��定 ", 0);
　　　DisplayString(17,yPos+High+1, " 取消 ", 0);
　　　break;
　　default:
　　　break;
　}
　DrawRect(0, 0, 239, yPos+High+16+4); /* �l�制外框 */
　/* MessageBox是模式对话框�Q�阻塞运行，�{�待按键 */
　while( (keyValue != KEY_OK) || (keyValue != KEY_CANCEL) )
　{
　　keyValue = getSysKey();
　}
　/* �q�回按键�c�d�� */
　if(keyValue== KEY_OK)
　{
　　return ID_OK;
　}
　else
　{
　　return ID_CANCEL;
　}
}

　　上述函数与我们��^素在VC++�{�中使用的MessageBox是何�{�的��似啊？实现�q�个函数�Q�你会看到它在嵌入式�pȝ��中的妙用是无�I�L��?br>
　　�ȝ��

　　本篇是本�p�d��文章中技巧性最��q��一��，它提供了嵌入式系�l�屏�q�显�C�方面一些很巧妙的处理方法，灉|��使用它们�Q�我们将不再被LCD上凌�׃��堪的昄��内容所困扰�?br>
　　屏幕乃嵌入式�pȝ��生存之重要辅助，面目可憎之显�C�将另用户逃之夭夭。屏�q�编�E�若处理不好�Q�将是��Y件中最不系�l�、最混�ؕ的部分，�W�者曾深受其害�?img src ="http://www.tkk7.com/faintbear/aggbug/13656.html" width = "1" height = "1" />

��力力力 2005-09-21 17:32 发表评论

C语言嵌入式系�l�编�E�修��g��?内存操作

��力力力 — Wed, 21 Sep 2005 09:30:00 GMT

C语言嵌入式系�l�编�E�修��g��?内存操作

作�?宋宝�? 更新日期:2005-07-22

数据指针

　　在嵌入式�pȝ��的编�E�中�Q�常常要求在特定的内存单元读写内容，汇编有对应的MOV指��o�Q�而除C/C++以外的其它编�E�语�a�基本没有直接讉K��l�对地址的能力。在嵌入式系�l�的实际调试中，多借助C语言指针所��h��的对�l�对地址单元内容的读写能力。以指针直接操作内存多发生在如下几种情况�Q?br>
　　(1) 某I/O芯片被定位在CPU的存储空间而非I/O�I�间�Q�而且寄存器对应于某特定地址�Q?br>
　　(2) 两个CPU之间以双端口RAM通信�Q�CPU需要在双端口RAM的特定单元（�U�Cؓmail box�Q�书写内容以在对方CPU产生中断�Q?br>
　　(3) ��d��在ROM或FLASH的特定单元所烧录的汉字和英文字模�?br>
　　譬如�Q?

unsigned char *p = (unsigned char *)0xF000FF00;
*p=11;

　　以上�E�序的意义�ؓ在绝对地址0xF0000+0xFF00(80186使用16位段地址�?6位偏�U�d��址)写入11�?br>
　　在��用绝对地址指针�Ӟ��要注意指针自增自减操作的�l�果取决于指针指向的数据�c�d��。上例中p++后的�l�果是p= 0xF000FF01�Q�若p指向int�Q�即�Q?br>

int *p = (int *)0xF000FF00;

　　p++(�?+p)的结果等同于�Q�p = p+sizeof(int)�Q�而p-(�?p)的结果是p = p-sizeof(int)�?br>
　　同理�Q�若执行�Q?br>

long int *p = (long int *)0xF000FF00;

　　则p++(�?+p)的结果等同于�Q�p = p+sizeof(long int) �Q�而p-(�?p)的结果是p = p-sizeof(long int)�?br>
　　��C��Q�CPU以字节�ؓ单位�~�址�Q�而C语言指针以指向的数据�c�d��长度作自增和自减。理解这一点对于以指针直接操作内存是相当重要的�?br>
　　函数指针

　　首先要理解以下三个问题：

　　�Q?�Q�C语言中函数名直接对应于函数生成的指��o代码在内存中的地址�Q�因此函数名可以直接赋给指向函数的指针；

　　�Q?�Q�调用函数实际上�{�同�?调�{指��o�Q�参��C��递处理＋回归位置入栈"�Q�本质上最核心的操作是��函数生成的目标代码的首地址赋给CPU的PC寄存器；

　　�Q?�Q�因为函数调用的本质是蟩转到某一个地址单元的code��L��行，所以可�?调用"一个根本就不存在的函数实体�Q�晕�Q�请往下看�Q?

　　��h��Z��可以获得的�Q何一本大学《微型计��机原理》教材，书中讲到�Q?86 CPU启动后蟩转至�l�对地址0xFFFF0�Q�对应C语言指针�?xF000FFF0�Q?xF000为段地址�Q?xFFF0为段内偏�U�）执行�Q�请看下面的代码�Q?br>

typedef void (*lpFunction) ( ); /* 定义一个无参数、无�q�回�c�d��?*/
/* 函数指针�c�d�� */
lpFunction lpReset = (lpFunction)0xF000FFF0; /* 定义一个函数指针，指向*/
/* CPU启动后所执行�W�一条指令的位置 */
lpReset(); /* 调用函数 */

　　在以上的�E�序中，我们�Ҏ��没有看到��M��一个函数实体，但是我们却执行了�q�样的函数调用：lpReset()�Q�它实际上�v��C��"软重�?的作用，跌��{到CPU启动后第一条要执行的指令的位置�?br>
　　��C��Q�函数无它，唯指令集合耻I��你可以调用一个没有函��C��的函敎ͼ�本质上只是换一个地址开始执行指令！

　　数组vs.动态申�?/b>

　　在嵌入式�pȝ��中动态内存申请存在比一般系�l�编�E�时更严格的要求�Q�这是因为嵌入式�pȝ��的内存空间往往是十分有限的�Q�不�l�意的内存泄露会很快��D��pȝ��的崩溃�?br>
　　所以一定要保证你的malloc和free成对出现�Q�如果你写出�q�样的一�D늨�序：

char * function(void)
{
　char *p;
　p = (char *)malloc(�?;
　if(p==NULL)
　　�?
　　�?/* 一�p�d��针对p的操�?*/
　return p;
}

　　在某处调用function()�Q�用完function中动态申��L��内存后将其free�Q�如下：

char *q = function();
�?br>free(q);

　　上述代码明显是不合理的，因�ؓ�q�反了malloc和free成对出现的原则，�?谁申��P��q��谁释�?原则。不满��q�个原则�Q�会��D��代码的耦合度增大，因�ؓ用户在调用function函数旉��要知道其内部�l�节�Q?br>
　　正确的做法是在调用处甌��内存�Q��ƈ传入function函数�Q�如下：

char *p=malloc(�?;
if(p==NULL)
�?
function(p);
�?br>free(p);
p=NULL;

　　而函数function则接收参数p�Q�如下：

void function(char *p)
{
　�?/* 一�p�d��针对p的操�?*/
}

　　基本上，动态申请内存方式可以用较大的数�l�替换。对于编�E�新手，�W�者推荐你��量采用数组�Q�嵌入式�pȝ��可以以博大的胸襟接收瑕疵�Q�而无�?��L��"错误。毕竟，以最�W�的方式苦练��功的郭靖胜�q�机��明却范政治错误走反革命道路的杨康�?br>
　　�l�出原则�Q?br>
　　�Q?�Q�尽可能的选用数组�Q�数�l�不能越界访问（真理��过一步就是谬误，数组��过界限��光荣地成全了一个�؜��q��嵌入式系�l�）�Q?br>
　　�Q?�Q�如果��用动态申��P��则申请后一定要判断是否甌��成功了，�q�且malloc和free应成对出玎ͼ�
关键字const

　　const意味着"只读"。区别如下代码的功能非常重要�Q�也是老生长叹�Q�如果你�q�不知道它们的区别，而且已经在程序界摸爬滚打多年�Q�那只能说这是一个悲哀�Q?br>

const int a;
int const a;
const int *a;
int * const a;
int const * a const;

　　�Q?�Q? 关键字const的作用是为给��M��代码的�h传达非常有用的信息。例如，在函数的形参前添加const关键字意味着�q�个参数在函��C��内不会被修改�Q�属�?�? 入参�?。在有多个�Ş参的时候，函数的调用者可以凭借参数前是否有const关键字，清晰的��L别哪些是输入参数�Q�哪些是可能的输出参数�?br>
　　�Q?�Q�合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参敎ͼ�防止其被无意的代码修改，�q�样可以减少bug的出现�?br>
　　const在C++语言中则包含了更丰富的含义，而在C语言中仅意味着�Q?只能�ȝ��普通变�?�Q�可以称其�ؓ"不能改变的变�?�Q�这个说法似乎很拗口�Q�但却最准确的表达了C语言中const的本质）�Q�在�~�译阶段需要的常数仍然只能�?define宏定义！故在C语言中如下程序是非法的：

const int SIZE = 10;
char a[SIZE]; /* 非法�Q�编译阶�D�不能用到变�?*/

　　关键字volatile

　　C语言�~�译器会对用户书写的代码�q�行优化�Q�譬如如下代码：

int a,b,c;
a = inWord(0x100); /*��d��I/O�I�间0x100端口的内容存入a变量*/
b = a;
a = inWord (0x100); /*再次��d��I/O�I�间0x100端口的内容存入a变量*/
c = a;

　　很可能被�~�译器优化�ؓ�Q?br>

int a,b,c;
a = inWord(0x100); /*��d��I/O�I�间0x100端口的内容存入a变量*/
b = a;
c = a;

　　但是�q�样的优化结果可能导致错误，如果I/O�I�间0x100端口的内容在执行�W�一�ơ读操作后被其它�E�序写入新��|��则其实第2�ơ读操作��d��的内容与�W�一�ơ不同，b和c的值应该不同。在变量a的定义前加上volatile关键字可以防止编译器的类��g��化，正确的做法是�Q?br>

volatile int a�Q?/td>

　　volatile变量可能用于如下几种情况�Q?br>
　　(1) �q�行讑֤�的硬件寄存器�Q�如�Q�状态寄存器�Q�例中的代码属于此类�Q�；

　　(2) 一个中断服务子�E�序中会讉K��到的非自动变�?也就是全局变量)�Q?br>
　　(3) 多线�E�应用中被几个�Q务共享的变量�?br>
　　CPU字长与存储器位宽不一致处�?/b>

　　在背景篇中提刎ͼ�本文�Ҏ��选择了一个与CPU字长不一致的存储芯片�Q�就是�ؓ了进行本节的讨论�Q�解决CPU字长与存储器位宽不一致的情况�?0186的字长�ؓ16�Q�而NVRAM的位宽�ؓ8�Q�在�q�种情况下，我们需要�ؓNVRAM提供��d��字节、字的接口，如下�Q?

typedef unsigned char BYTE;
typedef unsigned int WORD;
/* 函数功能�Q�读NVRAM中字�?
* 参数�Q�wOffset�Q�读取位�|�相对NVRAM基地址的偏�U?br>* �q�回�Q�读取到的字节�?br>*/
extern BYTE ReadByteNVRAM(WORD wOffset)
{
　LPBYTE lpAddr = (BYTE*)(NVRAM + wOffset * 2); /* ��Z��么偏�U�要×2? */

　return *lpAddr;
}

/* 函数功能�Q�读NVRAM中字
* 参数�Q�wOffset�Q�读取位�|�相对NVRAM基地址的偏�U?br>* �q�回�Q�读取到的字
*/
extern WORD ReadWordNVRAM(WORD wOffset)
{
　WORD wTmp = 0;
　LPBYTE lpAddr;
　/* ��d��高位字节 */
　lpAddr = (BYTE*)(NVRAM + wOffset * 2); /* ��Z��么偏�U�要×2? */
　wTmp += (*lpAddr)*256;
　/* ��d��低位字节 */
　lpAddr = (BYTE*)(NVRAM + (wOffset +1) * 2); /* ��Z��么偏�U�要×2? */
　wTmp += *lpAddr;
　return wTmp;
}

/* 函数功能�Q�向NVRAM中写一个字�?
*参数�Q�wOffset�Q�写入位�|�相对NVRAM基地址的偏�U?br>* byData�Q�欲写入的字�?br>*/
extern void WriteByteNVRAM(WORD wOffset, BYTE byData)
{
　�?br>}

/* 函数功能�Q�向NVRAM中写一个字 */
*参数�Q�wOffset�Q�写入位�|�相对NVRAM基地址的偏�U?br>* wData�Q�欲写入的字
*/
extern void WriteWordNVRAM(WORD wOffset, WORD wData)
{
　�?br>}

　　子�A问曰�Q�Why偏移要乘�??

　　子曰�Q�请看图1�Q?6�?0186�?位NVRAM之间互连只能以地址�U�A1对其A0,CPU本��n的A0与NVRAM不连接。因此，NVRAM的地址只能是偶数地址�Q�故每次�?x10为单位前�q�！

�? CPU与NVRAM地址�U�连�?/div>

　　子�A再问�Q�So why 80186的地址�U�A0不与NVRAM的A0�q�接�Q?br>
　　子曰�Q�请看《IT��》之《微机原理篇》，那里面讲�q�C��关于计算机组成的圣�h之道�?br>
　　�ȝ��

　　本篇主要讲述了嵌入式�pȝ��C�~�程中内存操作的相关技巧。掌握�ƈ深入理解关于数据指针、函数指针、动态申请内存、const及volatile关键字等�? 相关知识�Q�是一个优�U�的C语言�E�序设计师的基本要求。当我们已经牢固掌握了上�q�技巧后�Q�我们就已经学会了C语言�?9%�Q�因为C语言最�_�֍�的内�늚�在内�? 操作中体现�?br>
　　我们之所以在嵌入式系�l�中使用C语言�q�行�E�序设计�Q?9%是因为其强大的内存操作能力！

　　如果你爱�~�程�Q�请你爱C语言�Q?br>
　　如果你爱C语言�Q�请你爱指针�Q?br>
　　如果你爱指针�Q�请你爱指针的指针！

��力力力 2005-09-21 17:30 发表评论

��力力力 — Wed, 21 Sep 2005 09:29:00 GMT

C语言嵌入式系�l�编�E�修��g��?软�g架构��?/h1>
作�?宋宝�? 更新日期:2005-07-22

　　模块划分

　　模块划分�?�?是规划的意思，意指怎样合理的将一个很大的软�g划分��Z��p�d��功能独立的部分合作完成系�l�的需求。C语言作�ؓ一�U�结构化的程序设计语�a��Q�在模块的划分上主要依据功能�Q�依功能�q�行划分在面向对象设计中成�ؓ一个错误，牛顿�? 律遇��C��>相对论）�Q�C语言模块化程序设计需理解如下概念�Q?br>
　　�Q?�Q?模块��x��一�?c文�g和一�?h文�g的结合，头文�?.h)中是对于该模块接口的声明�Q?br>
　　�Q?�Q?某模块提供给其它模块调用的外部函数及数据需�?h中文件中冠以extern关键字声明；

　　�Q?�Q?模块内的函数和全局变量需�?c文�g开头冠以static关键字声明；

　　�Q?�Q?永远不要�?h文�g中定义变量！定义变量和声明变量的区别在于定义会��生内存分配的操作�Q�是汇编阶段的概念；而声明则只是告诉包含该声明的模块在连接阶�D�从其它模块��L��外部函数和变量。如�Q?br>

/*module1.h*/
int a = 5; /* 在模�?�?h文�g中定义int a */

/*module1 .c*/
#include "module1.h" /* 在模�?中包含模�?�?h文�g */

/*module2 .c*/
#include "module1.h" /* 在模�?中包含模�?�?h文�g */

/*module3 .c*/
#include "module1.h" /* 在模�?中包含模�?�?h文�g */

　　以上�E�序的结果是在模�?�?�?中都定义了整型变量a�Q�a在不同的模块中对应不同的地址单元�Q�这个世界上从来不需要这��L��E�序。正��的做法是：

/*module1.h*/
extern int a; /* 在模�?�?h文�g中声明int a */

/*module1 .c*/
#include "module1.h" /* 在模�?中包含模�?�?h文�g */
int a = 5; /* 在模�?�?c文�g中定义int a */

/*module2 .c*/
#include "module1.h" /* 在模�?中包含模�?�?h文�g */

/*module3 .c*/
#include "module1.h" /* 在模�?中包含模�?�?h文�g */

　　�q�样如果模块1�?�?操作a的话�Q�对应的是同一片内存单元�?br>
　　一个嵌入式�pȝ��通常包括两类模块�Q?br>
　　�Q?�Q�硬仉��动模块，一�U�特定硬件对应一个模块；

　　�Q?�Q��Y件功能模块，其模块的划分应满��低偶合、高内聚的要求�?br>
　　多�Q务还是单��d��

　　所�?单�Q务系�l?是指该系�l�不能支持多��d��q�发操作�Q�宏观串行地执行一个�Q务。而多��d��pȝ��则可以宏观�ƈ行（微观上可能串行）�?同时"执行多个��d��?br>
　　多�Q务的�q�发执行通常依赖于一个多��d��操作�pȝ��Q�OS�Q�，多�Q务OS的核心是�pȝ��调度器，它��用�Q务控制块�Q�TCB�Q�来��理��d��调度功能。TCB包括�? 务的当前状态、优先��、要�{�待的事件或资源、�Q务程序码的�v始地址、初始堆栈指针等信息。调度器在�Q务被�Ȁ�z�L��Q�要用到�q�些信息。此外，TCB�q�被用来�? 放�Q务的"上下�?�Q�context)。�Q务的上下文就是当一个执行中的�Q务被停止�Ӟ��所要保存的所有信息。通常�Q�上下文��是计算机当前的状态，也即各个寄存器的内容。当发生��d��切换�Ӟ��当前�q�行的�Q务的上下文被存入TCB�Q��ƈ��要被执行的��d��的上下文从它的TCB中取出，攑օ�各个寄存器中�?br>
　　嵌入式多��d��OS的典型例子有Vxworks、ucLinux�{�。嵌入式OS�q��遥不可及的神坛之物，我们可以用不�?000行代码实��C��个针�?0186处理器的功能最��单的OS内核�Q�作者正准备�q�行此项工作�Q�希望能��心得�A献给大家�?br>
　　�I�竟选择多�Q务还是单��d��方式�Q�依赖于软�g的体�p�L��否庞大。例如，�l�大多数手机�E�序都是多�Q务的�Q�但也有一些小灵通的协议栈是单�Q务的�Q�没有操作系�l�，它们的主�E�序轮流调用各个软�g模块的处理程序，模拟多�Q务环境�?br>单�Q务程序典型架�?/b>

　　�Q?�Q�从CPU复位时的指定地址开始执行；

　　�Q?�Q�蟩转至汇编代码startup处执行；

　　�Q?�Q�蟩转至用户�ȝ��序main执行�Q�在main中完成：

　　a.初试化各��g讑֤��Q?

　　b.初始化各软�g模块�Q?br>
　　c.�q�入��d�@环（无限循环�Q�，调用各模块的处理函数

　　用户�ȝ��序和各模块的处理函数都以C语言完成。用户主�E�序最后都�q�入了一个死循环�Q�其首选方案是�Q?br>

while(1)
{
}

　　有的�E�序员这样写�Q?br>

for(;;)
{
}

　　�q�个语法没有��切表达代码的含义，我们从for(;;)看不��Z��么，只有弄明白for(;;)在C语言中意味着无条件��@环才明白其意�?br>
　　下面是几�?著名"的死循环�Q?br>
　　�Q?�Q�操作系�l�是��d�@环；

　　�Q?�Q�WIN32�E�序是死循环�Q?br>
　　�Q?�Q�嵌入式�pȝ��软�g是死循环�Q?br>
　　�Q?�Q�多�U�程�E�序的线�E�处理函数是��d�@环�?br>
　　你可能会辩驳�Q�大声说�Q?凡事都不是绝对的�Q?�?�?都可以不是死循环"。Yes�Q�you are right�Q�但是你得不到鲜花和掌声。实际上�Q�这是一个没有太大意义的牛角��，因�ؓ�q�个世界从来不需要一个处理完几个消息��喊着要OS杀��d��的WIN32 �E�序�Q�不需要一个刚开始RUN��p��行了断的嵌入式系�l�，不需要莫名其妙启动一个做一点事��干掉自��q��U�程。有时候，�q�于严�}刉��的不是便利而是�ȝ��。君�? 见，五层的TCP/IP协议栈超��严谨的ISO/OSI七层协议栈大行其道成��Z��实上的标准？

　　�l�常有网友讨论：

printf("%d,%d",++i,i++); /* 输出是什么？*/
c = a+++b; /* c=? */

　　�{�类似问题。面对这些问题，我们只能发出��p��的感慨：世界上还有很多有意义的事情等着我们��L��化摄入的食物�?br>
　　实际上，嵌入式系�l�要�q�行��C��界末日�?br>
　　中断服务�E�序

　　中断是嵌入式�pȝ��中重要的�l�成部分�Q�但是在标准C中不包含中断。许多编译开发商在标准C上增加了对中断的支持�Q�提供新的关键字用于标示中断服务�E�序 (ISR)�Q�类��g��__interrupt�?program interrupt�{�。当一个函数被定义为ISR的时候，�~�译器会自动��函数增加中断服务�E�序所需要的中断现场入栈和出栈代码�?br>
　　中断服务�E�序需要满��_��下要求：

　　(1)不能�q�回��|��

　　(2)不能向ISR传递参敎ͼ�

　　(3) ISR应该��可能的短小�_�悍�Q?br>
　　(4) printf(char * lpFormatString,�?函数会带来重入和性能问题�Q�不能在ISR中采用�?br>
　　在某��目的开发中�Q�我们设计了一个队列，在中断服务程序中�Q�只是将中断�c�d��d��入该队列中，在主�E�序的死循环中不断扫描中断队列是否有中断�Q�有则取出队列中的第一个中断类型，�q�行相应处理�?br>

/* 存放中断的队�?*/
typedef struct tagIntQueue
{
　int intType; /* 中断�c�d�� */
　struct tagIntQueue *next;
}IntQueue;

IntQueue lpIntQueueHead;

__interrupt ISRexample ()
{
　int intType;
　intType = GetSystemType();
　QueueAddTail(lpIntQueueHead, intType)�Q?* 在队列尾加入新的中断 */
}

　　在主�E�序循环中判断是否有中断�Q?

While(1)
{
　If( !IsIntQueueEmpty() )
　{
　　intType = GetFirstInt();
　　switch(intType) /* 是不是很象WIN32�E�序的消息解析函�? */
　　{
　　　/* 对，我们的中断类型解析很�c�M��于消息驱�?*/
　　　case xxx: /* 我们�U�其�?中断驱动"吧？ */
　　　　�?br>　　　　break;
　　　case xxx:
　　　　�?br>　　　　break;
　　　�?br>　　}
　}
}

　　按上�q�方法设计的中断服务�E�序很小�Q�实际的工作都交�׃��E�序执行了�?br>��g驱动模块

　　一个硬仉��动模块通常应包括如下函敎ͼ�

　　�Q?�Q�中断服务程序ISR

　　�Q?�Q�硬件初始化

　　a.修改寄存器，讄��g参数�Q�如UART应设�|�其波特率，AD/DA讑֤�应设�|�其采样速率�{�）�Q?br>
　　b.��中断服务程序入口地址写入中断向量表：

/* 讄��中断向量�?*/
m_myPtr = make_far_pointer(0l); /* �q�回void far型指针void far * */
m_myPtr += ITYPE_UART; /* ITYPE_UART�Q?uart中断服务�E�序 */
/* 相对于中断向量表首地址的偏�U?*/
*m_myPtr = &UART _Isr; /* UART _Isr�Q�UART的中断服务程�?*/

　　�Q?�Q�设�|�CPU针对该硬件的控制�U?br>
　　a.如果控制�U�可作PIO�Q�可�~�程I/O�Q�和控制信号用，则设�|�CPU内部对应寄存器��其作为控制信��P��

　　b.讄��CPU内部的针对该讑֤�的中断屏蔽位�Q�设�|�中断方式（电��^触发�q�是边缘触发�Q��?br>
　　�Q?�Q�提供一�p�d��针对该设备的操作接口函数。例如，对于LCD�Q�其驱动模块应提供绘制像素、画�Uѝ��绘制矩��c��显�C�字�W�点�늭�函数�Q�而对于实旉��Q�其驱动模块则需提供获取旉��、设�|�时间等函数�?br>
　　C的面向对象化

　　在面向对象的语言里面�Q�出��C��cȝ��概念。类是对特定数据的特定操作的集合体。类包含了两个范��_��数据和操作。而C语言中的struct仅仅是数据的集合�Q�我们可以利用函数指针将struct模拟��Z��个包含数据和操作�?�c?。下面的C�E�序模拟了一个最��单的"�c?�Q?br>

#ifndef C_Class
#define C_Class struct
#endif
C_Class A
{
　C_Class A *A_this; /* this指针 */
　void (*Foo)(C_Class A *A_this); /* 行�ؓ�Q�函数指�?*/
　int a; /* 数据 */
　int b;
};

　　我们可以利用C语言模拟出面向对象的三个�Ҏ��：��装、��承和多态，但是更多的时候，我们只是需要将数据与行为封装以解决软�g�l�构混�ؕ的问题。C模拟面向对象思想的目的不在于模拟行�ؓ本��n�Q�而在于解��x��些情况下使用C语言�~�程时程序整体框架结构分散、数据和函数��p��的问题。我们在后箋章节会看到这��L��? 子�?

　　�ȝ��

　　本篇介绍了嵌入式�pȝ��~�程软�g架构斚w��的知识，主要包括模块划分、多��d��q�是单�Q务选取、单��d��E�序典型架构、中断服务程序、硬仉��动模块设计等�Q�从宏观上给��Z��一个嵌入式�pȝ��软�g所包含的主要元素�?br>
　　误��住：软�g�l�构是��Y件的灵魂�Q�结构�؜��q��E�序面目可憎�Q�调试、测试、维护、升�U�都极度困难�?img src ="http://www.tkk7.com/faintbear/aggbug/13654.html" width = "1" height = "1" />

��力力力 2005-09-21 17:29 发表评论

��力力力 — Wed, 21 Sep 2005 09:28:00 GMT

http://www.upsdn.net/(推荐下，感兴��的同志可以看看哈，便携�pȝ��开发网)

C语言嵌入式系�l�编�E�修��g��一:背景��?/h1>
作�?宋宝�? 更新日期:2005-08-30
来源:yesky.com
不同于一般�Ş式的软�g�~�程�Q�嵌入式�pȝ��~�程建立在特定的��g�q�_��上，势必要求其编�E�语�a�具备较强的硬件直接操作能力。无疑，汇编语言具备�q�样的特质。但是，归因于汇�~�语�a�开发过�E�的复杂性，它�ƈ不是嵌入式系�l�开发的一般选择。而与之相比，C语言--一�U?高��的低�U?语言�Q�则成�ؓ嵌入式系�l�开发的最佳�? 择。笔者在嵌入式系�l�项目的开发过�E�中�Q�一�ơ又一�ơ感受到C语言的精妙，沉醉于C语言�l�嵌入式开发带来的便利�?br>
　　�?�l�出了本文的讨论所��Z��的硬件��^収ͼ�实际上，�q�也是大多数嵌入式系�l�的��g�q�_��。它包括两部分：

　　�Q?�Q?以通用处理器�ؓ中心的协议处理模块，用于�|�络控制协议的处理；

　　�Q?�Q?以数字信号处理器�Q�DSP�Q��ؓ中心的信号处理模块，用于调制、解调和�?模信可��{换�?br>
　　本文的讨��Z��要围�l�以通用处理器�ؓ中心的协议处理模块进行，因�ؓ它更多地牉|��到具体的C语言�~�程技巧。而DSP�~�程则重点关注具体的数字信号处理��法�Q�主要涉及通信领域的知识，不是本文的讨论重炏V�?br>
　　着��g��讨论普遍的嵌入式�pȝ��C�~�程技巧，�pȝ��的协议处理模块没有选择特别的CPU�Q�而是选择了众所周知的CPU芯片--80186�Q�每一位学习过《微�? 原理》的读者都应该�Ҏ��芯片有一个基本的认识�Q�且对其指��o集比较熟悉�?0186的字长是16位，可以��d��到的内存�I�间�?MB�Q�只有实地址模式。C语言 �~�译生成的指针�ؓ32位（双字�Q�，�?6位�ؓ�D�地址�Q�低16位�ؓ�D�内�~�译�Q�一�D�|��?4KB�?br>

�? �pȝ��g架构

　　协议处理模块中的FLASH和RAM几乎是每个嵌入式�pȝ��的必备设备，前者用于存储程序，后者则是程序运行时指��o及数据的存放位置。系�l�所选择的FLASH和RAM的位宽都�?6位，与CPU一致�?br>
　　实时钟芯片可以�ؓ�pȝ��定时�Q�给出当前的�q�、月、日及具体时��_��时、分、秒及毫�U�）�Q�可以设定其�l�过一�D�|��间即向CPU提出中断或设定报警时间到来时向CPU提出中断�Q�类似闹钟功能）�?br>
　　NVRAM�Q�非易失��L��RAM�Q�具有掉电不丢失数据的特性，可以用于保存�pȝ��的设�|�信息，譬如�|�络协议参数�{�。在�pȝ��掉电或重新启动后�Q�仍然可以读取先前的讄��信息。其位宽�?位，比CPU字长��。文章特意选择一个与CPU字长不一致的存储芯片�Q��ؓ后文中一节的讨论创造条件�?br>
　　UART则完成CPU�q�行数据传输与RS-232串行数据传输的�{换，它可以在接收到[1~MAX_BUFFER]字节后向CPU提出中断�Q�MAX_BUFFER为UART芯片存储接收到字节的最大缓冲区�?br>
　　键盘控制器和昄��控制器则完成�pȝ��人机界面的控制�?br>
　　以上提供的是一个较完备的嵌入式�pȝ��g架构�Q�实际的�pȝ��可能包含更少的外设。之所以选择一个完备的�pȝ��Q�是��Z��后文更全面的讨论嵌入式系�l�C语言�~�程技巧的�Ҏ��面面�Q�所有设备都会成为后文的分析目标�?br>
　　嵌入式系�l�需要良好的软�g开发环境的支持�Q�由于嵌入式�pȝ��的目标机资源受限�Q�不可能在其上徏立庞大、复杂的开发环境，因而其开发环境和目标�q�行环境�怺� 分离。因此，嵌入式应用��Y件的开发方式一般是�Q�在宿主�?Host)上徏立开发环境，�q�行应用�E�序�~�码和交叉编译，然后宿主机同目标�?Target)�? 立连接，��应用程序下载到目标��Z��q�行交叉调试�Q�经�q�调试和优化�Q�最后将应用�E�序固化到目标机中实际运行�?

　　CAD-UL是适用�? x86处理器的嵌入式应用��Y件开发环境，它运行在Windows操作�pȝ��之上�Q�可生成x86处理器的目标代码�q��过PC机的COM口（RS-232串口�Q? 或以太网口下载到目标��Z��q�行�Q�如�?。其�ȝ��于目标机FLASH存储器中的monitor�E�序可以监控宿主机Windows调试�q�_��上的用户调试指��o�Q? 获取CPU寄存器的值及目标机存储空间、I/O�I�间的内宏V�?br>

�? 交叉开发环�?/div>

　　后箋章节��从软�g架构、内存操作、屏�q�操作、键盘操作、性能优化�{? 多方面阐�q�C语言嵌入式系�l�的�~�程技巧。��Y件架构是一个宏观概念，与具体硬件的联系不大�Q�内存操作主要涉及系�l�中的FLASH、RAM和NVRAM芯片�Q? 屏幕操作则涉及显�C�控制器和实旉��Q�键盘操作主要涉及键盘控制器�Q�性能优化则给��Z��些具体的减小�E�序旉��、空间消耗的技巧�?br>
　　在我们的修炼旅途中��经�q?5个关口，�q�些兛_��d��Z��c�，一�c�L��技巧型�Q�有很强的适用性；一�c�d��是常识型�Q�在理论上有些意义�?img src ="http://www.tkk7.com/faintbear/aggbug/13653.html" width = "1" height = "1" />

��力力力 2005-09-21 17:28 发表评论

修练8�q�C++面向对象�E�序设计之体�?林锐博士)

��力力力 — Fri, 09 Sep 2005 02:59:00 GMT
修练8�q�C++面向对象�E�序设计之体�?BR>

六年前，我刚热恋“面向对象”（Object-Oriented�Q�时�Q�一口气��C��了近十个定义。六�q�后�Q�我从几十万行程序中滚爬出来准备写点心得体会�Ӟ��却无法解释什么是“面向对象”，��p��说不清楚什么是数学那样。��Y件工�E�中的时髦术语“面向对象分析”和“面向对象设计”，通常是针对“需求分析”和“系�l�设计”环节的。“面向对象”有几大学派�Q�就象如来佛、上帝和真主用各自的方式定义了这个世界，�q�留下一堆经书来解释�q�个世界�?/P>
有些学者徏议这��h��“对象”：分析一个句子的语法�Q�找出名词和动词�Q�名词就是对象，动词则是对象的方法（卛_��敎ͼ��?/P>
当年国民党的文�h��Z��Ҏ��毛泽东的《沁园春·雪》，�Ҏ��h��朝遗老们写了一些对仗工整的诗，误��介石�q�目。老蒋看了气得大骂�Q�“娘希匹�Q�全都有一股棺材里腐尸的气呟뀂”我看了几千��늚�软�g工程资料�Q�终于发现自己有些“弱智”，无法理解“面向对象”的理论�Q�同旉��悟到“编�E�是��道理。�?/P>
面向对象�E�序设计语言很多�Q�如Smalltalk、Ada、Eiffel、Object Pascal、Visual Basic、C++�{�等。C++语言最讨�h喜欢�Q�因为它兼容C 语言�Q��ƈ且具备C 语言的性能。近几年�Q�一�U�叫Java 的纯面向对象语言�U�极一�Ӟ��不少人叫喊着要用Java 革C++的命。我认�ؓJava 好比是C++的外甥，虽然不是直接遗传的，但也几分象样。外甥在舅舅�w�上玩耍时�z�了一泡尿�Q�俩��Z��该�ؓ此而争��c�?/P>
关于C++�E�序设计的书藉非常多�Q�本章不讲C++的语法，只讲一些小��的�~�程道理。如果我能早几年明白�q�些��道理，��可以大大改善数十万行程序的质量了�?/P>
1. C++面向对象�E�序设计的重要概�?/STRONG>

早期革命��q��里有�q�样一个角�Ԍ��他说�Q�“我是党代表�Q�我代表党，我就是党。”后来他�l�同志们带来了灾难�?/P>
会用C++的程序员一定懂得面向对象程序设计吗�Q?/P>
不会用C++的程序员一定不懂得面向对象�E�序设计吗？

两者都未必。就象坏蛋入党后未必能成为好人，好�h不入党未必变成坏蛋那栗��?/P>
我不怕触犯众怒地说句大话�Q�“C++没有高手�Q�C 语言才有高手。”在用C 和C++�~�程8�q�之后，我深深地遗憾自己不是C 语言的高手，更遗憾没有�h�Ҏ��我如何进行面向对象程序设计。我和很多C++�E�序员一��P��在��n用到C++语法的好处时便以��己已�l�明白了面向对象�E�序设计。就象挤掉牙膏卖牙膏皮那��P��真是暴殄天物呀�?/P>
��Z��不懂拼音也会讲普通话�Q�如果懂得拼韛_��会把普通话讲得更好。不懂面向对象程序设计也可以用C++�~�程�Q�如果懂得面向对象程序设计则会把C++�E�序�~�得更好。本节讲�q�C��个非常基��的概念：“类与对象”、“��承与�l�合”、“虚函数与多态”。理解这些概念，有助于提高程序的质量�Q�特别是提高“可复用性”与“可扩充性”�?/P>
1.1 �c�M��对象

对象�Q�Object�Q�是�c�（Class�Q�的一个实例（Instance�Q�。如果将对象比作房子�Q�那么类��是房子的设计图�U�。所以面向对象程序设计的重点是类的设计，而不是对象的设计。类可以��数据和函数��装在一��P��其中函数表示了类的行为（或称服务�Q�。类提供关键字public、protected 和private 用于声明哪些数据和函数是公有的、受保护的或者是�U�有的�?/P>
�q�样可以辑ֈ�信息隐藏的目的，卌��c�M��仅公开必须要让外界知道的内容，而隐藏其它一切内宏V��我们不可以滥用�cȝ��装功能�Q�不要把它当成火锅，什么东襉K��往里扔�?/P>
�cȝ��设计是以数据��Z��心，�q�是以行��Zؓ中心�Q?/P>
��d��“以数据��Z��心”的那一�z��h��x��cȝ��内部数据�l�构�Q�他们习惯上��private �c�d��的数据写在前面，而将public �c�d��的函数写在后面，如表8.1(a)所�C��?/P>
��d��“以行�ؓ��Z��心”的那一�z��h��x��c�d��该提供什么样的服务和接口�Q�他们习惯上��public �c�d��的函数写在前面，而将private �c�d��的数据写在后面，如表8.1(b)所�C��?/P>

很多C++教课书主张在设计�c�L��“以数据��Z��心”。我坚持�q�且��读者在设计�c�L��“以行�ؓ��Z��心”，即首先考虑�c�d��该提供什么样的函数。Microsoft 公司的COM 规范的核心是接口设计�Q�COM 的接口就相当于类的公有函数[Rogerson 1999]。在�E�序设计斚w��Q�咱们不要怀疑Microsoft 公司的风根{�?/P>
设计孤立的类是比较容易的�Q�难的是正确设计基类及其�z��c�R��因为有些程序员搞不清楚“��扎쀝（Inheritance�Q�、“组合”（Composition�Q�、“多态”（ Polymorphism�Q�这些概��c�?

1.2 �l�承与组�?/P>
如果A 是基�c�，B 是A 的派生类�Q�那么B ��承A 的数据和函数。示例程序如下：

class A

{

public:

void Func1(void);

void Func2(void);

};

class B : public A

{

public:

void Func3(void);

void Func4(void);

};

// Example

main()

{

B b; // B的一个对�?/P>
b.Func1(); // B 从A �l�承了函数Func1

b.Func2(); // B 从A �l�承了函数Func2

b.Func3();

b.Func4();

}

�q�个��单的�C�Z��E�序说明了一个事实：C++的“��扎쀝特性可以提高程序的可复用性。正因�ؓ“��扎쀝太有用、太�Ҏ��用，才要防止��q��“��扎쀝。我们要�l�“��扎쀝立一些��用规则：

一、如果类A 和类B 毫不相关�Q�不可以��Z��使B 的功能更多些而让B �l�承A 的功能�?/P>
不要觉得“不吃白不吃”，让一个好端端的健壮青�q�无�~�无故地吃�h参补�w�体�?/P>
二、如果类B 有必要��用A 的功能，则要分两�U�情况考虑�Q?/P>
�Q?�Q�若在逻辑上B 是A 的“一�U�”（a kind of �Q�，则允许B �l�承A 的功能。如男�h�Q�Man�Q�是人（Human�Q�的一�U�，男孩�Q�Boy�Q�是男�h的一�U�。那么类Man 可以从类Human �z��Q�类Boy 可以从类Man �z��。示例程序如下：

class Human

{

�?/P>
};

class Man : public Human

{

�?/P>
};

class Boy : public Man

{

�?/P>
};

�Q?�Q�若在逻辑上A 是B 的“一部分”（a part of�Q�，则不允许B �l�承A 的功能，而是要用A和其它东西组合出B。例如眼�Q�Eye�Q�、��E�Q�Nose�Q�、口�Q�Mouth�Q�、耻I��Ear�Q�是��_��Head�Q�的一部分�Q�所以类Head 应该��q��Eye、Nose、Mouth、Ear �l�合而成�Q�不是派生而成。示例程序如下：

class Eye

{

public:

void Look(void);

};

class Nose

{

public:

void Smell(void);

};

class Mouth

{

public:

void Eat(void);

};

class Ear

{

public:

void Listen(void);

};

// 正确的设计，冗长的程�?/P>
class Head

{

public:

void Look(void) { m_eye.Look(); }

void Smell(void) { m_nose.Smell(); }

void Eat(void) { m_mouth.Eat(); }

void Listen(void) { m_ear.Listen(); }

private:

Eye m_eye;

Nose m_nose;

Mouth m_mouth;

Ear m_ear;

};

如果允许Head 从Eye、Nose、Mouth、Ear �z��而成�Q�那么Head ��自动具有Look、Smell、Eat、Listen �q�些功能�Q?/P>
// 错误的设�?/P>
class Head : public Eye, public Nose, public Mouth, public Ear

{

};

上述�E�序十分��短�ƈ且运行正��，但是�q�种设计却是错误的。很多程序员�l�不起“��扎쀝的诱惑而犯下设计错误�?/P>
一只公鸡��劲地�q�打一只刚下了蛋的母鸡�Q�你知道��Z��么吗�Q?/P>
因�ؓ母鸡下了鸭蛋�?/P>
本书3.3 节讲�q�“运行正��”的�E�序不见得就是高质量的程序，此处��是一个例证�?

1.3 虚函��C��多�?/P>
除了�l�承外，C++的另一个优良特性是支持多态，卛_��许将�z��cȝ��对象当作基类的对象��用。如果A 是基�c�，B 和C 是A 的派生类�Q�多态函数Test 的参数是A �?指针。那么Test 函数可以引用A、B、C 的对象。示例程序如下：

class A

{

public:

void Func1(void);

};

void Test(A *a)

{

a->Func1();

}

class B : public A

{

�?/P>
};

class C : public A

{

�?/P>
};

// Example

main()

{

A a;

B b;

C c;

Test(&a);

Test(&b);

Test(&c);

};

以上�E�序看不出“多态”有什么�h��|��加上虚函数和抽象基类后，“多态”的威力��显�C�出来了�?/P>
C++用关键字virtual 来声明一个函��Cؓ虚函敎ͼ��z��cȝ��虚函数将�Q�override�Q�基�c�d��应的虚函数的功能。示例程序如下：

class A

{

public:

virtual void Func1(void){ cout<< “This is A::Func1 \n”}

};

void Test(A *a)

{

a->Func1();

}

class B : public A

{

public:

virtual void Func1(void){ cout<< “This is B::Func1 \n”}

};

class C : public A

{

public:

virtual void Func1(void){ cout<< “This is C::Func1 \n”}

};

// Example

main()

{

A a;

B b;

C c;

Test(&a); // 输出This is A::Func1

Test(&b); // 输出This is B::Func1

Test(&c); // 输出This is C::Func1

};

如果基类A 定义如下�Q?/P>
class A

{

public:

virtual void Func1(void)=0;

};

那么函数Func1 叫作�U�虚函数�Q�含有纯虚函数的�c�d��作抽象基�c�R��抽象基�c�d��定义纯虚函数的形式�Q�具体的功能由派生类实现�?/P>
�l�合“抽象基�c�Z��和“多态”有如下�H�出优点�Q?/P>
�Q?�Q�应用程序不必�ؓ每一个派生类�~�写功能调用�Q�只需要对抽象基类�q�行处理卛_��。这一

招叫“以不变应万变”，可以大大提高�E�序的可复用性（�q�是接口设计的复用，而不是代码实现的复用�Q��?/P>
�Q?�Q�派生类的功能可以被基类指针引用�Q�这叫向后兼容，可以提高�E�序的可扩充性和可维护性。以前写的程序可以被��来写的�E�序调用不��为奇�Q�但是将来写的程序可以被以前写的�E�序调用那可了不赗��?

2 良好的编�E�风�?/STRONG>

内功深厚的武林高手出招往往�q�x�E无奇。同理，�~�程高手也不会用奇门怪招写程序。良好的�~�程风格是��生高质量�E�序的前提�?/P>
2.1 命名�U�定

有不��h�~�程时用拼音�l�函数或变量命名�Q�这样做�q�不能说明你很爱国，却会让用此程序的��p�（很多南方��Z��懂拼韻I��我就不懂�Q�。程序中的英文一般不会太复杂�Q�用词要力求准确。匈牙利命名法是Microsoft 公司倡导的[Maguire 1993]�Q�虽然很烦琐�Q�但用习惯了也就成了自然。没有�h��你采用何�U�命名法�Q�但有一点应该做刎ͼ�自己的程序命名必��M��致�?/P>
以下是我�~�程旉��用的命名�U�定�Q?/P>
�Q?�Q�宏定义用大写字母加下划�U�表�C�，如MAX_LENGTH�Q?/P>
�Q?�Q�函数用大写字母开头的单词�l�合而成�Q�如SetName, GetName �Q?/P>
�Q?�Q�指针变量加前缀p�Q�如*pNode �Q?/P>
�Q?�Q�BOOL 变量加前�~�b�Q�如bFlag �Q?/P>
�Q?�Q�int 变量加前�~�i�Q�如iWidth �Q?/P>
�Q?�Q�float 变量加前�~�f�Q�如fWidth �Q?/P>
�Q?�Q�double 变量加前�~�d�Q�如dWidth �Q?/P>
�Q?�Q�字�W�串变量加前�~�str�Q�如strName �Q?/P>
�Q?�Q�枚丑֏�量加前缀e�Q�如eDrawMode �Q?/P>
�Q?0�Q�类的成员变量加前缀m_�Q�如m_strName, m_iWidth �Q?/P>
对于int, float, double 型的变量�Q�如果变量名的含义十分明显，则不加前�~��Q�避免烦琐。如用于循环的int 型变量i,j,k �Q�float 型的三维坐标�Q�x,y,z�Q�等�?/P>
2.2 使用断言

�E�序一般分为Debug 版本和Release 版本�Q�Debug 版本用于内部调试�Q�Release 版本发行�l�用户��用。断�a�assert 是仅在Debug 版本起作用的宏，它用于检查“不应该”发生的情况。以下是一个内存复制程序，在运行过�E�中�Q�如果assert 的参��Cؓ假，那么�E�序��׃��中止�Q�一般地�q�会出现提示对话�Q�说明在什么地方引发了assert�Q��?/P>
//复制不重叠的内存�?/P>
void memcpy(void *pvTo, void *pvFrom, size_t size)

{

void *pbTo = (byte *) pvTo;

void *pbFrom = (byte *) pvFrom;

assert( pvTo != NULL && pvFrom != NULL );

while(size - - > 0 )

*pbTo + + = *pbFrom + + ;

return (pvTo);

}

assert 不是一个仓促拼凑�v来的宏，��Z��不在�E�序的Debug 版本和Release 版本引�v差别�Q�assert 不应该��生�Q何副作用。所以assert 不是函数�Q�而是宏。程序员可以把assert 看成一个在��M��pȝ��状态下都可以安全��用的无害��试手段�?/P>
很少有比跟踪到程序的断言�Q�却不知道该断言的作用更让�h沮��的事了。你化了很多旉��Q�不是�ؓ了排除错误，而只是�ؓ了弄清楚�q�个错误到底是什么。有的时候，�E�序员偶��还会设计出有错误的断言。所以如果搞不清楚断�a��查的是什么，��很隑ֈ�断错误是出现在程序中�Q�还是出现在断言中。幸�q�的是这个问题很好解冻I��只要加上清晰的注释即可。这本是显而易见的事情�Q�可是很��有�E�序员这样做。这好比一个�h在森林里�Q�看到树上钉着一块“危险”的大牌子。但危险到底是什么？树要倒？有废井？有野兽？除非告诉��Z��“危险”是什么，否则�q�个警告牌难以�v到积极有效的作用。难以理解的断言常常被程序员忽略�Q�甚臌��删除。[Maguire 1993]

以下是��用断�a�的几个原则：

�Q?�Q��用断�a�捕捉不应该发生的非法情况。不要�؜淆非法情况与错误情况之间的区别，后者是必然存在的�ƈ且是一定要作出处理的�?/P>
�Q?�Q��用断�a�对函数的参数�q�行��认�?/P>
�Q?�Q�在�~�写函数�Ӟ��要进行反复的考查�Q��ƈ且自问：“我打算做哪些假定？”一旦确定了�?/P>
假定�Q�就要��用断�a�对假定进行检查�?/P>
�Q?�Q�一般教�U�书都鼓��q��序员们进行防错性的�E�序设计�Q�但要记住这�U�编�E�风��g��隐瞒错误。当�q�行防错性编�E�时�Q�如果“不可能发生”的事情的确发生了，则要使用断言�q�行报警�?

2.3 new、delete 与指�?/P>
在C++中，操作�W�new 用于甌��内存�Q�操作符delete 用于释放内存。在C 语言中，函数malloc 用于甌��内存�Q�函数free 用于释放�?存。由于C++兼容C 语言�Q�所以new、delete、malloc、free 都有可能一起��用。new 能比malloc �q�更多的事，它可以申请对象的内存�Q�而malloc 不能。C++和C 语言中的指针威猛无比�Q�用错了会带来灾难。对于一个指针p�Q�如果是用new甌��的内存，则必��ȝ��delete 而不能用free 来释放。如果是用malloc 甌��的内存，则必��ȝ��free 而不能用delete 来释放。在用delete 或用free 释放p 所指的内存后，应该马上昑ּ�地将p �|��ؓNULL�Q�以防下�ơ��用p 时发生错误。示例程序如下：

void Test(void)

{

float *p;

p = new float[100];

if(p==NULL) return;

�?/ do something

delete p;

p=NULL; // 良好的编�E�风�?/P>
// 可以�l�箋使用p

p = new float[500];

if(p==NULL) return;

�?/ do something else

delete p;

p=NULL;

}

我们�q�要预防“野指针”，“野指针”是指向“垃�䏀�内存的指针�Q�主要成因有两种�Q?/P>
�Q?�Q�指针没有初始化�?/P>
�Q?�Q�指针指向已�l�释攄��内存�Q�这�U�情冉|��让�h防不胜防�Q�示例程序如下：

class A

{

public:

void Func(void){…}

};

void Test(void)

{

A *p;

{

A a;

p = &a; // 注意a 的生命期

}

p->Func(); // p 是“野指针”，�E�序出错

}

2.4 使用const

在定义一个常量时�Q�const �?define 更加灉|��。用const 定义的常量含有数据类型，该常量可以参与逻辑�q�算。例如：

const int LENGTH = 100; // LENGTH 是int �c�d��

const float MAX=100; // MAX 是float �c�d��

#define LENGTH 100 // LENGTH 无类�?/P>
#define MAX 100 // MAX 无类�?/P>
除了能定义常量外�Q�const �q�有两个“保护”功能：

一、强制保护函数的参数��g��发生变化

以下�E�序中，函数f 不会改变输入参数name 的��|��但是函数g 和h 都有可能改变name的倹{�?/P>
void f(String s); // pass by value

void g(String &s); // pass by referance

void h(String *s); // pass by pointer

main()

{

String name=“Dog�?

f(name); // name 的��g��会改�?/P>
g(name); // name 的值可能改�?/P>
h(name); // name 的值可能改�?/P>
}

对于一个函数而言�Q�如果其�?’或�?’类型的参数只作输入用，不作输出用，那么应当在该参数前加上const�Q�以��保函数的代码不会改变该参数的��|��如果改变了该参数的��|��~�译器会出现错误警告�Q�。因此上�q�程序中的函数g 和h 应该定义成：

void g(const String &s);

void h(const String *s);

二、强制保护类的成员函��C��改变��M��数据成员的�?/P>
以下�E�序中，�c�stack 的成员函数Count 仅用于计敎ͼ��Z��保Count 不改变类中的��M��数据成员的��|��应将函数Count 定义成const �c�d��?/P>
class Stack

{

public:

void push(int elem);

void pop(void);

int Count(void) const; // const �c�d��的函�?/P>
private:

int num;

int data[100];

};

int Stack::Count(void) const

{

++ num; // �~�译错误�Q�num 值发生变�?/P>
pop(); // �~�译错误�Q�pop ��改变成员变量的�?/P>
return num;

}

2.5 其它��

�Q?�Q�不要编写一条过分复杂的语句�Q�紧凑的C++/C 代码�q�不见到能得到高效率的机器代码，却会降低�E�序的可理解性，�E�序出错误的几率也会提高�?/P>
�Q?�Q�不要编写集多种功能于一�w�的函数�Q�在函数的返回��g��Q�不要将正常值和错误标志混在一赗��?/P>
�Q?�Q�不要将BOOL 值TRUE 和FALSE 对应�? �? �q�行�~�程。大多数�~�程语言��FALSE定义�?�Q��Q何非0 值都是TRUE。Visual C++��TRUE 定义�?�Q�而Visual Basic 则将TRUE定义�?1。示例程序如下：

BOOL flag;

�?/P>
if(flag) { // do something } // 正确的用�?/P>
if(flag==TRUE) { // do something } // 危险的用�?/P>
if(flag==1) { // do something } // 危险的用�?/P>
if(!flag) { // do something } // 正确的用�?/P>
if(flag==FALSE) { // do something } // 不合理的用法

if(flag==0) { // do something } // 不合理的用法

�Q?�Q�小心不要将�? =”写成�?”，�~�译器不会自动发现这�U�错误�?/P>
�Q?�Q�不要将123 写成0123�Q�后者是八进制的数倹{�?/P>
�Q?�Q�将自己�l�常犯的�~�程错误记录下来�Q�制成表��D��在计��机旁边�?/P>
3 ��结

C++/C �E�序设计如同��林寺的武功一样博大精深，我练�? �q�_��大概只学��C��三成。所以无��Z��么时候，都不要觉得自��q��~�程水��^天下�W�一�Q�看到别人好的技术和风格�Q�要虚心学习。本章的内容��得可怜，��p��口��时只�l�你一颗杨梅吃�Q�你一定不�q�瘾。我借花献佛�Q�推荐一本好书：Marshall P. Cline 著的《C++ FAQs》[Cline 1995]。你看了后一定会赞不�l�口。会�~�写C++/C �E�序�Q�不要因此得意洋�z�，�q�只是程序员基本的技能要求而已。如果把�pȝ��分析和系�l�设计比作“战略决�{�”，那么�~�程充其量只是“战术”。如果指挥官是个大笨蛋，士兵再勇敢也会吃败仗。所以我们程序员不要只把眼光盯在�E�序上，要让自己博学多才。我们应该向北京胡同里的��孩们学习，他们��小�q�纪��p��指点江山�Q�评��Z��界大事�?/P>

��力力力 2005-09-09 10:59 发表评论

c++ primer �W�记�Q�名字空��_��

��力力力 — Mon, 11 Jul 2005 05:24:00 GMT

8.5关于名字�I�间定义
    全局实体(global entity)
    全局名字�I�间污染(global namespace pollution)

8.5.1名字�I�间定义
    namespace 开��_��后面是名字空间的名字�?/FONT>

    namespace cplusplus_primer {
     class matrix {/*****/};
     void inverse(matrix &);
     matrix operator+(const matrix &m1,matrix &m2)
     {
      /******/
     }
     const double pi = 3.1416;

    }

    在名字空间cplusplus_primer中声明的�cȝ��名字�?BR>    cplusplus_primer::matrix
    函数的名字是
    cplusplus_primer::inverse()
    帔R��的名字是
    cplusplus_primer::pi

    �c�，函数�Q�常量被声明它的名字�I�间的名字限定修饎ͼ�
    �q�些名字被成为限定修饰符(qualified name)

    名字�I�间的定义不一定是�q�箋�?例如
    namespace cplusplus_primer{
    class matrix {/*****/}
    const double pi = 3.1416;

    }

    namespace cplusplus_primer{
    void inverse(matrix &);
    matrix operator+ (const matrix &m1,const matrix &m2)
        {/********/}
    }

    名字�I�间的定义可是非�q�箋的，�q�对生成一个库很有帮助,它��我们更容易将库的源代码组�l�成
    接口和实现部分�?/FONT>

8.5.2域操作符
     ::
     用户声明的名字空间成员名自动被加上前�~��Q�名字空间名后面加上域操作符(::),名字�I�间成员�?BR>     ��p��名字�I�间名进行限定修饰�?/FONT>

     名字�I�间成员的声明被隐藏在其名字�I�间中，除非我们为编译器指定查找的声明的名字�I�间,否则
     �~�译器将在当前域及嵌套包含当前域的域中查找该名字的声明�?/FONT>

     注意�Q�！�Q?BR>     域操作符也可以被用来引用全局名字�I�间的成员。因为全局名字�I�间没有名字�?BR>     ::member_name
     指的是全局名字�I�间的成员�?/FONT>

     #include
     const int max = 65000;
     const int lineLength = 12;

     void fibonacci(int max)
     {
        if (max <2) return;
cout << "0 1";
int v1 = 0,v2=1,cur;
for (int ix=3;ix <= max;++ix)
{
     cur = v1+v2;
     if(cur>::max) break;   //引用全局名字�I�间的变量；
     cout << cur <<"";
     v1=v2;
     v2=cur;
     if(ix % lineLength ==0) cout << endl;
}
     }

8.5.3 嵌套名字�I�间

      。。。。�?/FONT>

8.6 使用名字�I�间成员

     使用限定修饰的名字�Ş式namespace_name::member_name来引用名字空��_��毫无疑问是非帔R��烦的�?/FONT>

     using 声明�Q�using指示�W?/FONT>

8.6.1 名字�I�间别名

     namespace International_Business_Machines
     {/*********/}

     namespace IBM = International_Business_Machines;

8.6.2 using声明


      namespace cplusplus_primer
      {
        namespace MatrixLib
        {
         class matrix {/******/};
        }
      }


      using cplusplus::MatrixLib::matrix;


      using 声明引入的名字有以下�Ҏ��：
       1> 它在该域中必��d��一�?BR>       2> 由外围域中声明引入的相同名字被其隐藏�?BR>       3> 它被嵌套域中的相同名字的声明隐藏�?/FONT>

       namespace blip {
        int bi = 16,bj = 15, bk = 23;

       }

       int bj = 0;

       void mainip()
       {
         using blip::bi;    //函数mainip()中的bi指向blip::bi
++bi;              //讄��blip::bi�?7
using blip::bj     //隐藏全局域中的bj
++bj;
int bk;            //bk在局部域中声�?BR> using blip:bk;     //错误:在mainip()中重复定义bk

       }

       int wrongInit = bk; //错误�Q�bk在这里不可见

8.6.3 using 指示�W?/FONT>

       namespace blip{
       int bi = 16,bj = 15, bk = 23;
       }

       int bj = 0;

       void mainip()
       {
         using namespace blip;

++bi;       //讄��blip::bi�?7;
++bj;        //错误�Q�二义�?BR>                 全局bj�q�是blip:bj?

         ++::bj;     // 讄��全局bj�?
++blip::bj; // 讄��blip::bj�?6
int bk = 97; //局部bk隐藏blip:bk
++bk;        //讄��局部bk�?8


       }

当我们把一个应用程序移植到一个包装在名字�I�间中的新版本时�Q�using指示�W�非�?BR>有用�Q�但是��用多个using指示�W�会引�v全局名字�I�间污染问题�?BR>用多个选择性的using声明来代替using指示�W�会使这个问题最��化�Q�由多个using
声明引�v的二义性的错误在声明点��p��被检��到�Q�因此徏议��用using声明而不�?BR>using指示�W?以便更好地控制程序中地全局名字�I�间污染问题�?BR>

��力力力 2005-07-11 13:24 发表评论

内存��理<�?gt;

��力力力 — Mon, 11 Jul 2005 05:20:00 GMT

2004�q?11�?3�?
17 : 07 内存��理

节选自《高质量C++�~�程指南》中的《内存管理》，�q�对其进行简单整�?.....

内存分配方式
---------------------------------------------------------------------------------------------

内存分配方式有三�U�：
---------------------------
�Q?�Q?从静态存储区域分配。内存在�E�序�~�译的时候就已经分配好，�q�块内存在程序的整个�q�行期间都存在�?例如全局变量static变量�?BR>�Q?�Q?在栈上创建。在执行函数�Ӟ��函数内局部变量的存储单元都可以在栈上创徏�Q�函数执行结束时�q�些存储单元自动被释放。栈内存分配�q�算内置于处理器的指令集中，效率很高�Q�但是分配的内存定w��有限�?BR>�Q?�Q?从堆上分配，亦称动态内存分配。程序在�q�行的时候用malloc或new甌��L��多少的内存，�E�序员自��p��责在何时用free或delete释放内存。动态内存的生存期由我们军_��Q��用非常灵�z�，但问题也最多�?/FONT>

常见的内存错误及其对�{?BR>------------------------------------------------------------------------------------------
发生内存错误是�g非常�ȝ��的事情。编译器不能自动发现�q�些错误�Q�通常是在�E�序�q�行时才能捕捉到。而这些错误大多没有明昄��症状�Q�时隐时玎ͼ�增加了改错的隑ֺ�。有时用��h��气冲冲地把你找来，�E�序却没有发生�Q何问题，你一赎ͼ�错误又发作了�?/FONT>

常见的内存错误及其对�{�如下：

1>内存分配未成功，却��用了它�?BR>------------------------------------------
�~�程新手常犯�q�种错误�Q�因��Z��们没有意识到内存分配会不成功。常用解军_��法是�Q�在使用内存之前�� 指针是否为NULL。如果指针p是函数的参数�Q�那么在函数的入口处用assert(p!=NULL)�q�行��查。如�?nbsp; 是用malloc或new来申请内存，应该用if(p==NULL) 或if(p=NULL)�q�行防错处理�?/FONT>

2>内存分配虽然成功�Q�但是尚未初始化��引用它
------------------------------------------
犯这�U�错误主要有两个起因�Q�一是没有初始化的观念；二是误以为内存的�~�省初值全为零�Q�导致引用初错误�Q�例如数�l�）�?BR>内存的缺省初值究竟是什么�ƈ没有�l�一的标准，��管有些时候�ؓ零��|��我们宁可信其无不可信其有。所以无论用何种方式创徏数组�Q�都别忘了赋初��|��即便是赋零��g��不可省略�Q�不要嫌�ȝ��?/FONT>

3>内存分配成功�q�且已经初始化，但操作越�q�了内存的边界�?BR>------------------------------------------
例如在��用数�l�时�l�常发生下标"�?"或�?��?"的操作。特别是在for循环语句中，循环�ơ数很容易搞错，��D��数组操作��界�?/FONT>

4>忘记了释攑ֆ�存，造成内存泄露�?BR>------------------------------------------
含有�q�种错误的函数每被调用一�ơ就丢失一块内存。刚开始时�pȝ��的内存充��I��你看不到错误。终有一�ơ程序突然死掉，�pȝ��出现提示�Q�内存耗尽。动态内存的甌��与释攑ֿ��配对，�E�序中malloc与free的��用次��C��定要相同�Q�否则肯定有错误�Q�new/delete同理�Q��?/FONT>

5>释放了内存却�l�箋使用它�?BR>------------------------------------------
有三�U�情况：
�Q?�Q�程序中的对象调用关�p�过于复杂，实在难以搞清楚某个对象究竟是否已�l�释放了内存�Q�此时应该重新设计数据结构，从根本上解决对象��理的�؜乱局面�?BR>�Q?�Q�函数的return语句写错了，注意不要�q�回指向"栈内�?�?指针"或�?引用"�Q�因��内存在函��C��l�束时被自动销毁�?BR>�Q?�Q��用free或delete释放了内存后�Q�没有将指针讄��为NULL。导致��?野指�?�?/FONT>

【规�?】用malloc或new甌��内存之后�Q�应该立��x��查指针值是否�ؓNULL。防止��用指针��gؓNULL的内存�?BR>【规�?】不要忘��Cؓ数组和动态内存赋初倹{��防止将未被初始化的内存作�ؓ叛_��g��用�?BR>【规�?】避免数�l�或指针的下标越界，特别要当心发�?�?"或�?��?"操作�?BR>【规�?】动态内存的甌��与释攑ֿ��配对，防止内存泄漏�?BR>【规�?】用free或delete释放了内存之后，立即��指针设�|��ؓNULL�Q�防止��?野指�?�?/FONT>

------------------------------------------------------------------------------------
指针与数�l�的�Ҏ��
-----------------
C++/C�E�序中，指针和数�l�在不少地方可以�怺�替换着用，让�h产生一�U�错觉，以�ؓ两者是�{��h的�?BR>
数组
-------------
数组要么在静态存储区被创建（如全局数组�Q�，要么在栈上被创徏。数�l�名对应着�Q�而不是指向）一块内存，其地址与容量在生命期内保持不变�Q�只有数�l�的内容可以改变�?/FONT>

指针
--------------
指针可以随时指向��L��c�d��的内存块�Q�它的特征是"可变"�Q�所以我们常用指针来操作动态内存。指针远比数�l�灵�z�，但也更危险�?/FONT>

下面以字�W�串��Z��比较指针与数�l�的�Ҏ��?/FONT>

1.修改内容
------------------------------------------
�C�Z��1中，字符数组a的容量是6个字�W�，其内容�ؓhello\0。a的内容可以改变，如a[0]= 'X'�?BR>指针p指向帔R��字符�?world"�Q�位于静态存储区�Q�内容�ؓworld\0�Q�，帔R��字符串的内容是不可以被修改的�?BR>从语法上看，�~�译器�ƈ不觉得语句p[0]= ‘X'有什么不妥，但是该语句企图修改常量字�W�串的内容而导致运行错误�?BR>

�C�Z��7-3-1 修改数组和指针的内容
   ------------------------------
   char a[] = "hello";
   a[0] = 'X';
   cout << a << endl;
   char *p = "world"; // 注意p指向帔R��字符�?nbsp;
   p[0] = 'X'; // �~�译器不能发现该错误cout << p << endl;


2.内容复制与比�?BR>------------------------------------------
数组复制
--------
不能�Ҏ��l�名�q�行直接复制与比较。示�?中，若想把数�l�a的内容复制给数组b�Q�不能用语句 b = a �Q�否则将产生�~�译错误。应该用标准库函数strcpy�q�行复制。同理，比较b和a的内�Ҏ��否相同，不能用if(b==a) 来判断，应该用标准库函数strcmp�q�行比较�?/FONT>

指针复制
--------
语句p = a �q�不能把a的内容复制指针p�Q�而是把a的地址赋给了p。要惛_��制a的内容，可以先用库函数malloc为p甌��一块容量�ؓstrlen(a)+1个字�W�的内存�Q�再用strcpy�q�行字符串复制。同理，语句if(p==a) 比较的不是内容而是地址�Q�应该用库函数strcmp来比较�?/FONT>

�C�Z��2 数组和指针的内容复制与比�?BR> -----------------------------------
        // 数组...
char a[] = "hello";
char b[10];
strcpy(b, a); //不能用b = a;
if(strcmp(b, a) == 0) // 不能�?nbsp; if (b == a)...
// 指针...
int len = strlen(a);
char *p = (char *)malloc(sizeof(char)*(len+1));
strcpy(p,a); // 不要�?p = a;
if(strcmp(p, a) == 0) // 不要�?if (p == a)...

3 计算内存定w��
------------------------------------------
数组
----
用运��符sizeof可以计算出数�l�的定w��Q�字节数�Q��?BR>�C�Z��3中，sizeof(a)的值是12�Q�注意别忘了'\0'�Q��?/FONT>

指针
----
指针p指向a�Q�但是sizeof(p)的值却�?。这是因为sizeof(p)得到的是一个指针变量的字节敎ͼ�
相当于sizeof(char*)�Q�而不是p所指的内存定w��?/FONT>

C++/C语言没有办法知道指针所指的内存定w��Q�除非在甌��内存时记住它�?/FONT>

注意
----
当数�l�作为函数的参数�q�行传递时�Q�该数组自动退化�ؓ同类型的指针�?BR>�C�Z��3中，不论数组a的容量是多少�Q�sizeof(a)始终�{�于sizeof(char *)�?BR>
       �C�Z��3 计算数组和指针的内存定w��
-----------------------------
        char a[] = "hello world";
char *p = a; cout<< sizeof(a) << endl;// 12字节
cout<< sizeof(p) << endl;// 4字节

�C�Z��3�Q�b�Q?数组退化�ؓ指针
-----------------------------
void Func(char a[100])
{
cout<< sizeof(a) << endl;// 4字节而不�?00字节
   }

4指针参数是如何传递内存的�Q?BR>------------------------------------------
如果函数的参数是一个指针，不要指望用该指针�ȝ��请动态内存�?BR>�C�Z��4-1中，Test函数的语句GetMemory(str, 200)�q�没有��str获得期望的内存，str依旧是NULL�Q��ؓ什么？

�C�Z��4-1 试图用指针参数申请动态内�?BR> ----------------------------------
void GetMemory(char *p, int num)
{
p = (char *)malloc(sizeof(char) * num);
}
void Test(void)
{
char *str = NULL;
GetMemory(str, 100);// str 仍然�?NULL
strcpy(str, "hello"); // �q�行错误
}

毛病出在函数GetMemory中。编译器��L��要�ؓ函数的每个参数制作��时副本，
指针参数p的副本是 _p�Q�编译器�?_p = p。如果函��C��内的�E�序修改了_p的内容，
��导致参数p的内容作相应的修攏V��这��是指针可以用作输出参数的原因�?BR>在本例中�Q�_p甌��了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变�?BR>所以函数GetMemory�q�不能输��Z�Q何东�ѝ�?BR>事实上，每执行一�ơGetMemory��׃��泄露一块内存，因�ؓ没有用free释放内存�?/FONT>

如果非得要用指针参数�ȝ��请内存，那么应该改用"指向指针的指�?�Q�见�C�Z��4-2�?/FONT>

�C�Z��4-2用指向指针的指针甌��动态内�?BR> ------------------------------------
void GetMemory2(char **p, int num)
{
*p = (char *)malloc(sizeof(char) * num);
}
void Test2(void)
{
char *str = NULL;
GetMemory2(&str, 100); // 注意参数�?&str�Q�而不是str
strcpy(str, "hello");
cout<< str << endl;
free(str);
}

�׃��"指向指针的指�?�q�个概念不容易理解，我们可以用函数返回值来传递动态内存�?BR>�q�种�Ҏ��更加��单，见示�?-3�?/FONT>

�C�Z��4-3 用函数返回值来传递动态内�?BR> -----------------------------------
char *GetMemory3(int num)
{
char *p = (char *)malloc(sizeof(char) * num);
return p;
}
void Test3(void)
{
char *str = NULL;
str = GetMemory3(100);
strcpy(str,"hello");
cout<< str << endl;
free(str);
}

用函数返回值来传递动态内存这�U�方法虽然好用，但是常常有�h把return语句用错了。这里强调不要用return语句�q�回指向"栈内�?的指针，因�ؓ该内存在函数�l�束时自动消亡，见示�?-4�?/FONT>

�C�Z��4-4 return语句�q�回指向"栈内�?的指�?BR> --------------------------------------------
char *GetString(void)
{
char p[] = "hello world";
return p;// �~�译器将提出警告
}
void Test4(void)
{
char *str = NULL;str = GetString();// str 的内�Ҏ��垃圾
cout<< str << endl;
}

用调试器逐步跟踪Test4�Q�发现执行str = GetString语句后str不再是NULL指针�Q?BR>但是str的内容不�?hello world"而是垃圾�?/FONT>

如果把示�?-4改写成示�?-5�Q�会怎么��P��

�C�Z��4-5 return语句�q�回帔R��字符�?BR> -----------------------------------
char *GetString2(void)
{
char *p = "hello world";
return p;
}
void Test5(void)
{
char *str = NULL;
str = GetString2();
cout<< str << endl;
}

函数Test5�q�行虽然不会出错�Q�但是函数GetString2的设计概念却是错误的�?BR>因�ؓGetString2内的"hello world"是常量字�W�串�Q�位于静态存储区�Q�它在程序生命期内恒定不变�?BR>无论什么时候调用GetString2�Q�它�q�回的始�l�是同一�?只读"的内存块�?/FONT>

5 free和delete把指针怎么啦？
------------------------------------------
别看free和delete的名字恶狠狠的（��其是delete�Q�，
它们只是把指针所指的内存�l�释放掉�Q�但�q�没有把指针本��n�q�掉�?BR>用调试器跟踪�C�Z��5�Q�发现指针p被free以后其地址仍然不变�Q�非NULL�Q�，
只是该地址对应的内存是垃圾�Q�p成了"野指�?�?BR>如果此时不把p讄��为NULL�Q�会让�h误以为p是个合法的指针�?BR>如果�E�序比较长，我们有时��C��住p所指的内存是否已经被释放，
在��l��用p之前�Q�通常会用语句if (p !=NULL)�q�行防错处理�?BR>很遗憾，此时if语句起不到防错作用，因�ؓ即便p不是NULL指针�Q?BR>它也不指向合法的内存块�?/FONT>

�C�Z��5 p成�ؓ野指�?BR> --------------------
char *p = (char *) malloc(100);
strcpy(p, "hello");
free(p);        // p 所指的内存被释放，但是p所指的地址仍然不变 ...
if(p != NULL) // 没有起到防错作用
{      strcpy(p, "world"); // 出错
}

6 动态内存会被自动释攑֐��Q?BR>------------------------------------------
函数体内的局部变量在函数�l�束时自动消亡。很多�h误以为示�?是正��的�?BR>理由是p是局部的指针变量�Q�它消亡的时候会让它所指的动态内存一起完蛋。这是错觉！

�C�Z��7-6 试图让动态内存自动释�?BR> ------------------------------
void Func(void)
{
char *p = (char *) malloc(100); // 动态内存会自动释放吗？
}

我们发现指针有一�?似是而非"的特征：
------------------------------------
�Q?�Q�指针消亡了�Q��ƈ不表�C�它所指的内存会被自动释放�?BR>�Q?�Q�内存被释放了，�q�不表示指针会消亡或者成了NULL指针�?BR>     �q�表明释攑ֆ�存�ƈ不是一件可以草率对待的事。也许有��Z��服气�Q?BR>     一定要扑և�可以草率行事的理由：
     如果�E�序�l�止了运行，一切指针都会消亡，动态内存会被操作系�l�回收�?BR>     既然如此�Q�在�E�序临终前，��可以不必释攑ֆ�存、不必将指针讄��为NULL了�?BR>     �l�于可以��h��而不会发生错误了吧？
惛_��。如果别人把那段�E�序取出来用到其它地�Ҏ��么办？

7 杜绝"野指�?
------------------------------------------
"野指�?不是NULL指针�Q�是指向"垃圾"内存的指针�?BR>��Z��一般不会错用NULL指针�Q�因为用if语句很容易判断�?BR>但是"野指�?是很危险的，if语句对它不�v作用�?/FONT>

"野指�?的成因主要有两种�Q?/FONT>

�Q?�Q�指针变量没有被初始化。�Q何指针变量刚被创建时不会自动成�ؓNULL指针�Q?BR>它的�~�省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化�Q?BR>要么��指针设�|��ؓNULL�Q�要么让它指向合法的内存。例�?BR> char *p = NULL;
char *str = (char *) malloc(100);

�Q?�Q�指针p被free或者delete之后�Q�没有置为NULL�Q�让��以�ؓp是个合法的指针。参�?.5节�?/FONT>

�Q?�Q�指针操作超��了变量的作用范围。这�U�情况让人防不胜�Ԍ��C�Z��E�序如下�Q?BR> class A
{
public:
void Func(void){ cout << "Func of class A" << endl;
}

void Test(void)
{
A *p;
{
A a;
p = &a; // 注意 a 的生命期
}
p->Func();// p�?野指�?
}

函数Test在执行语句p->Func()�Ӟ��对象a已经消失�Q�而p是指向a的，所以p��成�?野指�?�?BR>但奇怪的是我�q�行�q�个�E�序时居然没有出错，�q�可能与�~�译器有兟�?/FONT>

8 有了malloc/free��Z��么还要new/delete �Q?BR>------------------------------------------
malloc与free是C++/C语言的标准库函数�Q�new/delete是C++的运��符�?BR>它们都可用于甌��动态内存和释放内存�?/FONT>

对于非内部数据类型的对象而言�Q�光用maloc/free无法满��动态对象的要求�?BR>对象在创建的同时要自动执行构造函敎ͼ�对象在消亡之前要自动执行析构函数�?BR>�׃��malloc/free是库函数而不是运��符�Q�不在编译器控制权限之内�Q?BR>不能够把执行构造函数和析构函数的�Q务强加于malloc/free�?BR>
因此C++语言需要一个能完成动态内存分配和初始化工作的�q�算�W�new�Q�以及一个能完成清理与释攑ֆ�存工作的�q?/FONT>

��符delete。注意new/delete不是库函数�?BR>我们先看一看malloc/free和new/delete如何实现对象的动态内存管理，见示�?�?/FONT>

�C�Z��8 用malloc/free和new/delete如何实现对象的动态内存管�?BR> -------------------------------------------------------------
class Obj
{
public :
Obj(void){ cout << "Initialization" << endl; }
~Obj(void){cout << "Destroy" << endl; }
void Initialize(void){ cout << "Initialization" << endl; }
void    Destroy(void){ cout << "Destroy" << endl; }
};
void UseMallocFree(void)
{
Obj *a = (obj *)malloc(sizeof(obj)); // 甌��动态内�?
a->Initialize(); // 初始�?BR> a->Destroy(); // 清除工作
free(a);// 释放内存
}
void UseNewDelete(void)
{
Obj *a = new Obj;// 甌��动态内存�ƈ且初始化
delete a;// 清除�q�且释放内存
}

�c�Obj的函数Initialize模拟了构造函数的功能�Q�函数Destroy模拟了析构函数的功能�?BR>函数UseMallocFree中，�׃��malloc/free不能执行构造函��C��析构函数�Q?BR>必须调用成员函数Initialize和Destroy来完成初始化与清除工作�?BR>函数UseNewDelete则简单得多�?/FONT>

所以我们不要企囄��malloc/free来完成动态对象的内存��理�Q�应该用new/delete�?BR>�׃��内部数据�c�d��?对象"没有构造与析构的过�E�，对它们而言malloc/free和new/delete是等��L��?BR>
既然new/delete的功能完全覆盖了malloc/free�Q��ؓ什么C++不把malloc/free淘汰出局呢？
�q�是因�ؓC++�E�序�l�常要调用C函数�Q�而C�E�序只能用malloc/free��理动态内存�?/FONT>

如果用free释放"new创徏的动态对�?�Q�那么该对象因无法执行析构函数而可能导致程序出错�?BR>如果用delete释放"malloc甌��的动态内�?�Q�理��Z��讲程序不会出错，但是该程序的可读性很差�?BR>所以new/delete必须配对使用�Q�malloc/free也一栗��?/FONT>

9 内存耗尽怎么办？
------------------------------------------
如果在申请动态内存时找不到��够大的内存块malloc和new��返回NULL指针�Q�宣告内存申请失败�?BR>通常有三�U�方式处�?内存耗尽"问题�?/FONT>

�Q?�Q�判断指针是否�ؓNULL�Q�如果是则马上用return语句�l�止本函数。例如：
void Func(void)
{
A *a = new A;
if(a == NULL)
{
   return;
}
...
}

�Q?�Q�判断指针是否�ؓNULL�Q�如果是则马上用exit(1)�l�止整个�E�序的运行。例如：
void Func(void)
{
A *a = new A;
if(a == NULL)
{
   cout << "Memory Exhausted" << endl;
   exit(1);
}
...
}

�Q?�Q��ؓnew和malloc讄��异常处理函数�?/FONT>

例如Visual C++可以用_set_new_hander函数为new讄��用户自己定义的异常处理函敎ͼ�
也可以让malloc享用与new相同的异常处理函数。详�l�内容请参考C++使用手册�?/FONT>

上述�Q?�Q�（2�Q�方式��用最普遍。如果一个函数内有多处需要申请动态内存，
那么方式�Q?�Q�就昑־�力不从心�Q�释攑ֆ�存很�ȝ��Q�，应该用方式（2�Q�来处理�?/FONT>

很多��Z��忍心用exit(1)�Q�问�Q?不编写出错处理程序，让操作系�l�自��p��册��不行�Q?
不行。如果发�?内存耗尽"�q�样的事情，一般说来应用程序已�l�无药可救�?BR>如果不用exit(1) 把坏�E�序杀死，它可能会��x��操作�pȝ��?BR>道理如同�Q�如果不把歹徒击毙，歹徒在老死之前会犯下更多的�|��?/FONT>

有一个很重要的现象要告诉大家。对�?2位以上的应用�E�序而言
�Q�无论怎样使用malloc与new�Q�几乎不可能��D��"内存耗尽"�?BR>我在Windows 98下用Visual C++�~�写了测试程序，见示�?�?BR>�q�个�E�序会无休止地运行下去，�Ҏ��不会�l�止�?BR>因�ؓ32位操作系�l�支�?虚存"�Q�内存用完了�Q�自动用��盘�I�间��替�?BR>我只听到��盘嘎吱嘎吱地响�Q�Window 98已经累得寚w��盘、鼠标毫无反应�?/FONT>

我可以得��么一个结论：对于32位以上的应用�E�序�Q?内存耗尽"错误处理�E�序毫无用处。这下可把Unix和Windows�E�序员们乐坏了：反正错误处理�E�序不�v作用�Q�我��׃��写了�Q�省了很多麻烦�?/FONT>

我不惌��D��者，必须��Q�不加错误处理将��D��E�序的质量很差，千万不可因小失大�?/FONT>

�C�Z��9试图耗尽操作�pȝ��的内�?BR> void main(void)
{
   float *p = NULL;
   while(TRUE)
   {
    p = new float[1000000];
    cout << "eat memory" << endl;
    if(p==NULL) exit(1);
   }
}

10 malloc/free 的��用要�?BR>------------------------------------------
函数malloc的原型如下：
void * malloc(size_t size);
用malloc甌��一块长度�ؓlength的整数类型的内存�Q�程序如下：
int *p = (int *) malloc(sizeof(int) * length);
我们应当把注意力集中在两个要素上�Q?�c�d��转换"�?sizeof"�?BR> malloc�q�回值的�c�d��是void *�Q�所以在调用malloc时要昑ּ�地进行类型�{换，
��void * 转换成所需要的指针�c�d��?BR> malloc函数本��n�q�不识别要申��L��内存是什么类型，它只兛_��内存的��d��节数�?BR>我们通常��C��住int,float�{�数据类型的变量的确切字节数。例如int变量�?6位系�l�下�?个字�?BR>�Q�在32位下�?个字节；而float变量�?6位系�l�下�?个字节，�?2位下也是4个字节�?/FONT>

最好用以下�E�序作一�ơ测试：
cout << sizeof(char) << endl;
cout << sizeof(int) << endl;
cout << sizeof(unsigned int) << endl;
cout << sizeof(long) << endl;
cout << sizeof(unsigned long) << endl;
cout << sizeof(float) << endl;
cout << sizeof(double) << endl;
cout << sizeof(void *) << endl;

在malloc�?()"中��用sizeof�q�算�W�是良好的风��|��但要当心有时我们会昏了头�Q�写�?p = malloc(sizeof(p))�q�样的程序来�?/FONT>

函数free的原型如下：

void free( void * memblock );

��Z��么free函数不象malloc函数那样复杂呢？�q�是因�ؓ指针p的类型以及它所指的内存的容量事先都是知道的�Q�语句free(p)能正��地释放内存。如果p是NULL指针�Q�那么free对p无论操作多少�ơ都不会出问题�?BR>如果p不是NULL指针�Q�那么free对p�q�箋操作两次��׃��D��E�序�q�行错误�?/FONT>

11 new/delete 的��用要�?BR>------------------------------------------

�q�算�W�new使用��h��要比函数malloc��单得多，例如�Q?BR>int *p1 = (int *)malloc(sizeof(int) * length);
int *p2 = new int[length];
�q�是因�ؓnew内置了sizeof、类型�{换和�c�d��安全��查功能。对于非内部数据�c�d��的对象而言�Q?BR>new在创建动态对象的同时完成了初始化工作�?BR>如果对象有多个构造函敎ͼ�那么new的语句也可以有多�U��Ş式�?BR>例如
class Obj
{
public :
Obj(void); // 无参数的构造函�?BR> Obj(int x); // 带一个参数的构造函�?BR>...
}
void Test(void)
{
Obj *a = new Obj;
Obj *b = new Obj(1); // 初��gؓ1
...
delete a;
delete b;
}
如果用new创徏对象数组�Q�那么只能��用对象的无参数构造函数。例�?BR> Obj *objects = new Obj[100]; // 创徏100个动态对�?BR>不能写成
Obj *objects = new Obj[100](1);// 创徏100个动态对象的同时赋初�?
在用delete释放对象数组�Ӟ��留意不要丢了�W�号‘[]'。例�?BR> delete []objects; // 正确的用�?BR>delete objects; // 错误的用�?BR>后者相当于delete objects[0]�Q�漏掉了另外99个对象�?/FONT>

12 一些心得体�?BR>------------------------------------------
�Q?�Q�越是怕指针，��p��要��用指针。不会正��用指针，肯定��不上是合格的程序员�?BR>�Q?�Q�必��d��?使用调试器逐步跟踪�E�序"的习惯，只有�q�样才能发现问题的本质�?/FONT>

最后，说一句："呵呵�Q�有炚w��Q�不知道大家有没有时间把它看完？"

��力力力 2005-07-11 13:20 发表评论

说明以下关键字的作用 auto static register const volatile extern

��力力力 — Wed, 22 Jun 2005 02:39:00 GMT

说明以下关键字的作用 (�?

auto　　static�?/FONT>　　register　　const 　　volatile 　　extern
http://blog.yesky.com/Blog/xioxu/archive/2005/06/03/138294.html

(1)auto

　　�q�个�q�个关键字用于声�?SPAN class=hilite3>变量的生存期��动，卛_��不在��M��c�R��结构、枚举、联合和函数中定义的变量视�ؓ全局变量�Q�而在函数中定义的变量视�ؓ局�?SPAN class=hilite3>变量。这个关键字不怎么多写�Q�因为所有的变量默认��是auto的�?

(2)register

　　�q�个关键字命令编译器��可�?/FONT>的将变量存在CPU内部寄存器中而不是通过内存��d��讉K��以提高效率�?

(3)static

　　常见的两�U�用�?
　　　　1>�l�计函数被调用的�ơ数;
　　　　2>减少局部数�l�徏立和赋值的开销.变量的徏立和赋值是需要一定的处理器开销的，特别是数�l�等含有较多元素的存储类型。在一些含有较多的变量�q�且被经常调用的函数中，可以��一些数�l�声明�ؓstatic�c�d��Q�以减少建立或者初始化�q�些变量的开销.

　　详细说明:
　　　　1>�?SPAN class=hilite3>变量会被攑֜��E�序的全局存储��Z��Q�这样可以在下一�ơ调用的时候还可以保持原来的赋倹{��这一�Ҏ��它与堆栈变量和堆变量的区别�?
　　　　2>�?SPAN class=hilite3>变量用static告知�~�译器，自己仅仅�?SPAN class=hilite3>变量的作用范围内可见。这一�Ҏ��它与全局变量的区别�?
　　　　3>当static用来修饰全局变量�Ӟ��它就改变了全局变量的作用域�Q��其不能被别的�E�序extern�Q�限制在了当前文仉��Q�但是没有改变其存放位置�Q�还是在全局静态储存区�?/FONT>
　　使用注意:
　　　　1>若全局变量仅在单个C文�g中访问，则可以将�q�个变量修改为静态全局变量�Q�以降低模块间的耦合度；
　　　　2>若全局变量仅由单个函数讉K��Q�则可以��这�?SPAN class=hilite3>变量改�ؓ该函数的静态局�?SPAN class=hilite3>变量�Q�以降低模块间的耦合度；
　　　　3>设计和��用访问动态全局变量、静态全局变量、静态局�?SPAN class=hilite3>变量的函数时�Q�需要考虑重入问题(只要输入数据相同��应产生相同的输�?�?
(4)const

　　�?SPAN class=hilite1>const修饰的东襉K��受到强制保护�Q�可以预防意外的变动�Q�能提高�E�序的健壮性。它可以修饰函数的参数、返回��|��甚至函数的定义体�?

　　作用:
　　　　1>修饰输入参数
　　　　　　a.对于非内部数据类型的输入参数�Q�应该将“��g��递”的方式改�ؓ�?SPAN class=hilite1>const引用传递”，目的是提高效率。例如将void Func(A a) 改�ؓvoid Func(const A &a)�?
　　　　　　b.对于内部数据�c�d��的输入参敎ͼ�不要��“��g��递”的方式改�ؓ�?SPAN class=hilite1>const引用传递”。否则既达不到提高效率的目的�Q�又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)�?
　　　　2>�?SPAN class=hilite1>const修饰函数的返回�?
　　　　　　a.如果�l�以“指针传递”方式的函数�q�回值加const修饰�Q�那么函数返回��|��x��针）的内容不能被修改�Q�该�q�回值只能被赋给�?SPAN class=hilite1>const修饰的同�c�d��指针�?
　　　　　　　如对于： const char * GetString(void);
　　　　　　　如下语句��出现编译错误：
　　　　　　　char *str = GetString();//cannot convert from 'const char *' to 'char *'�Q?
　　　　　　　正确的用法是�Q?
　　　　　　　const char *str = GetString();
　　　　　　b.如果函数�q�回值采用“��g��递方式”，�׃��函数会把�q�回值复制到外部临时的存储单元中�Q�加const修饰没有��M��价倹{�?如不要把函数int GetInt(void) 写成const int GetInt(void)�?
　　　　3>const成员函数的声明中�Q?SPAN class=hilite1>const关键字只能放在函数声明的��N��,表示该类成员不修改对�?
　　　说明�Q?
　　　　const type m; //修饰m��Z��可改�?
　　　�C�Z��Q?
　　　　typedef char * pStr; //新的�c�d��pStr;
　　　　char string[4] = "abc";
　　　　const char *p1 = string�Q?
　　　　p1++; //正确�Q�上边修饰的�?p1,p1可变
　　　　const pStr p2 = string;
　　　　p2++; //错误�Q�上边修饰的是p2�Q�p2不可�?*p2可变
　　　同理�Q?SPAN class=hilite1>const修饰指针时用此原则判断就不会��h��了�?
　　　　const int *value; //*value不可变，value可变
　　　　int* const value; //value不可变，*value可变
　　　　const (int *) value; //(int *)是一�U�type,value不可�?*value可变
　　　　　　　　　　　　　　//逻辑上这��L��解，�~�译不能通过�Q�需要tydef int* NewType;
　　　　const int* const value;//*value,value都不可变
(5)volatile

　　表明某个变量的值可能在外部被改变，优化器在用到�q�个变量时必��L��ơ都��心地重新读取这�?SPAN class=hilite3>变量的��|��而不是��用保存在寄存器里的备份。它可以适用于基��c�d��如：int,char,long......也适用�?SPAN class=hilite1>C的结构和C++的类。当对结构或者类对象使用volatile修饰的时候，�l�构或者类的所有成员都会被视�ؓvolatile.
　　该关键字在多�U�程环境下经�怋�用，因�ؓ在编写多�U�程的程序时�Q�同一�?SPAN class=hilite3>变量可能被多个线�E�修改，而程序通过�?SPAN class=hilite3>变量同步各个�U�程�?
　　��单示例：
　　　DWORD __stdcall threadFunc(LPVOID signal)
　　　{
　　　　　int* intSignal=reinterpret_cast(signal);
　　　　　*intSignal=2;
　　　　　while(*intSignal!=1)
　　　　　sleep(1000);
　　　　　return 0;
　　　}
　　该线�E�启动时��intSignal �|��ؓ2�Q�然后��@环等待直到intSignal �? 旉��出。显然intSignal的值必��d��外部被改变，否则该线�E�不会退出。但是实际运行的时候该�U�程却不会退出，即��在外部将它的值改�?�Q�看一下对应的伪汇�~�代码就明白了：
　　　　　mov ax,signal
　　　　　label:
　　　　　if(ax!=1)
　　　　　goto label
　　对于C�~�译器来��_��它�ƈ不知道这个��g��被其他线�E�修攏V��自然就把它cache在寄存器里面�?SPAN class=hilite1>C �~�译器是没有�U�程概念�?�q�时候就需要用到volatile。volatile 的本意是指：�q�个值可能会在当前线�E�外部被改变。也��是��_��我们要在threadFunc中的intSignal前面加上volatile关键字，�q�时候，�~�译器知道该变量的��g��在外部改变，因此每次讉K��?SPAN class=hilite3>变量时会重新��d��Q�所作的循环变�ؓ如下面伪码所�C�：
　　　　　label:
　　　　　mov ax,signal
　　　　　if(ax!=1)
　　　　　goto label

　　注意�Q?/FONT>一个参数既可以�?SPAN class=hilite1>const同时是volatile�Q�是volatile因�ؓ它可能被意想不到地改变。它�?SPAN class=hilite1>const因�ؓ�E�序不应该试囑֎�修改它�?
(6)extern

　　extern 意�ؓ“外来的”···它的作用在于告诉编译器�Q�有�q�个变量�Q�它可能不存在当前的文�g中，但它肯定要存在于工程中的某一个源文�g中或者一个Dll的输��Z��?/FONT>

��力力力 2005-06-22 10:39 发表评论

��力力力 — Tue, 21 Jun 2005 05:59:00 GMT

memset��h��

作者：tianzhushan     发表旉��Q?002/09/03 09:08am

版主�Q?BR>   请问�Q?BR>   memset ,memcpy 和strcpy 的根本区别？
   我总觉得memset,memcpy 可以用strcpy�{�代�?nbsp;

--------------------------------------------------------------------------------
此文章相兌��?

该文章有15个相兌��论如下：(点这儿可以发表评�?

zhuhuix 发表于： 2002/09/03 09:14am

char str[100];
memset(str,0,100);
memcpy(str,"This is a",9);
strcpy(&str[9],"example!");

yuejw 发表于： 2002/09/03 09:14am

它们用处不同�Q�但大部分情况下可以完成相同的要求�?BR>memset用来对一�D�内存空间全部设�|��ؓ某个字符�?/P>
memcpy用来做内存拷贝，你可以拿它拷贝�Q何数据类型的对象�?/P>
strcpy��只能拷贝字�W�串了，它遇�?\0'��q��束拷贝�?BR>

HopeCao 发表于： 2002/09/03 10:02am

很详�l�！

tianzhushan 发表于： 2002/09/03 05:37pm

各位�Q?nbsp;
   能否��p��三者的最典型的应用各举一个例子�?BR>   �l�合例子�Q�说说他们的区别和联�p�，以及��Z��么用�q�个而不用另外一个�?BR>   ��详�l�越好�?BR>   谢谢�Q?

betydu 发表于： 2002/09/04 09:21am

对版主yuejw的补�?BR>memset用来对一�D�内存空间全部设�|��ؓ某个字符�Q�一般用在对定义的字�W�串�q�行初始化�ؓ�?’或‘\0’；�?char a[100];memset(a, '\0', sizeof(a));
memcpy用来做内存拷贝，你可以拿它拷贝�Q何数据类型的对象�Q�可以指定拷贝的数据长度�Q�例�Q�char a[100],b[50]; memcpy(b, a, sizeof(b));注意如用sizeof(a)�Q�会造成b的内存地址溢出�?/P>
strcpy��只能拷贝字�W�串了，它遇�?\0'��q��束拷贝；例：char a[100],b[50];strcpy(a,b);如用strcpy(b,a)�Q�要注意a中的字符串长度（�W�一个‘\0’之前）是否��过50位，如超�q�，则会造成b的内存地址溢出�?BR>

iloveunix 发表于： 2002/09/04 04:56pm

补充�Q�我的一点心�?BR>memset可以方便的清�I�Z��个结构类型的变量或数�l��?BR>如：
struct sample_struct
{
char   csName[16];
int    iSeq;
int    iType;
};

对于变量
struct sample_strcut stTest;

一般情况下�Q�清�I�stTest的方法：
stTest.csName[0]='\0';
stTest.iSeq=0;
stTest.iType=0;

用memset��非常方便：
memset(&stTest,0,sizeof(struct sample_struct));

如果是数�l�：
struct sample_struct   TEST[10];
�?BR>memset(TEST,0,sizeof(struct sample_struct)*10);

zhtrue 发表于： 2002/09/04 05:06pm

对这个问题有疑问�Q�不是对函数的疑问，而是因�ؓ没有弄懂mem和str的区别�?BR>mem是一�D�内存，他的长度�Q�必��M��自己��C��
str也是一�D�内存，不过它的长度�Q�你不用讎ͼ�随时都可以计��出�?BR>所以memcpy需要第三个参数�Q�而strcpy不需�?BR>

tianzhushan 发表于： 2002/09/05 06:19pm

谢谢各位的高见！��弟受益匪浅

凌曦发表于： 2002/09/05 09:47pm

str也可以用用个参数的strncpy(a,b,n)

arbol 发表于： 2002/09/06 03:02pm

�q�有�Q�记住memcpy是不拯��最后的�l�止�W�的

�~�程��子发表于： 2002/09/12 00:58am

��g��的邮政老兄好像说错了吧�Q�应该是strcpy不拷�?\0'的，而memcpy应该是通吃�Q�见着什么拷贝什么�?

chrmhf 发表于： 2002/09/13 08:29am

memset主要应用是初始化某个内存�I�间�?BR>memcpy是用于COPY源空间的数据到目的空间中�?BR>strcpy用于字符串COPY,遇到‘\0’，��结束�?BR>�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－
如果你理解了�q�些�Q�你应该知道他们的区别：例如你初始化某块�I�间的时候，用到memcpy
那么应该怎么写，是不是显得很�W��?BR>int m[100]
->memset((void*)m,0x00,sizeof(int)*100);//GOOD
..memcpy((void*)m,"\0\0\0\0....",sizeof(int)*100);//foolish

HopeCao 发表于： 2002/09/13 01:58pm

strcpy
原型�Q�extern char *strcpy(char *dest,char *src);
用法�Q?include
功能�Q�把src所指由NULL�l�束的字�W�串复制到dest所指的数组中�?BR> 说明�Q�src和dest所指内存区域不可以重叠且dest必须有��够的�I�间来容�U�src的字�W�串�?BR>       �q�回指向dest的指针�?BR>memcpy
原型�Q�extern void *memcpy(void *dest, void *src, unsigned int count);
用法�Q?include
功能�Q�由src所指内存区域复制count个字节到dest所指内存区域�?BR> 说明�Q�src和dest所指内存区域不能重叠，函数�q�回指向dest的指针�?BR>memset
原型�Q�extern void *memset(void *buffer, int c, int count);
用法�Q?include
功能�Q�把buffer所指内存区域的前count个字节设�|�成字符c�?BR> 说明�Q�返回指向buffer的指针�?BR>

�~�程��子发表于： 2002/09/15 09:38pm

呵呵�Q�各位都是高手，真是不厌其烦的谆谆教导啊�Q?BR>

obss 发表于： 2002/09/17 06:25pm

谢谢�Q�有些收�?

��力力力 2005-06-21 13:59 发表评论

c++常见问题

��力力力 — Tue, 21 Jun 2005 05:56:00 GMT

一�?include “filename.h”和#include filename.h>的区�?/FONT>

#include “filename.h”是指编译器��从当前工作目录上开始查找此文�g

#include filename.h>是指�~�译器将从标准库目录中开始查找此文�g

二、头文�g的作�?/FONT>

加强安全��?/FONT>

通过头文件可能方便地调用库功能，而不必关心其实现方式

三�? , &修饰�W�的位置

对于*�?amp;修饰�W�，��Z��避免误解�Q�最好将修饰�W�紧靠变量名

四、if语句

不要��布��变量与��M��D��行比较，那会很容易出错的�?/FONT>

整�Ş变量必须要有�c�d��相同的��D��行比�?/FONT>

��点变量最好少比点�Q�就��要比也要有��D��行限�?/FONT>

指针变量要和NULL�q�行比较�Q�不要和布尔型和整�Ş比较

五、const�?define的比�?/FONT>

const有数据类型，#define没有数据�c�d��

个别�~�译器中const可以�q�行调试�Q?define不可以进行调�?/FONT>

在类中定义常量有两种方式

1�?在类在声明常量，但不赋��|��在构造函数初始化表中�q�行赋��|��

2�?用枚举代替const帔R��?/FONT>

六、C++函数中值的传递方�?/FONT>

有三�U�方式：��g��?Pass by value)、指针传�?Pass by pointer)、引用传�?Pass by reference)

void fun(char c) //pass by value

void fun(char *str) //pass by pointer

void fun(char &str) //pass by reference

如果输入参数是以��g��递的话，最好��用引用传递代替，因�ؓ引用传递省��M��临时对象的构造和析构

函数的类型不能省略，��q��没有也要加个void

七、函��C��中的指针或引用常量不能被�q�回

Char *func(void)

{

char str[]=”Hello Word�?

//�q�个是不能被�q�回的，因�ؓstr是个指定变量�Q�不是一般的��|��函数�l�束后会被注销�?/FONT>

return str;

}

函数体内的指针变量�ƈ不会随着函数的消亡而自动释�?/FONT>

八、一个内存拷贝函数的实现�?/FONT>

void *memcpy(void *pvTo,const void *pvFrom,size_t size)

{

assert((pvTo!=NULL)&&(pvFrom!=NULL));

byte *pbTo=(byte*)pvTo; //防止地址被改�?/FONT>

byte *pbFrom=(byte*)pvFrom;

while (size-- >0)

pbTo++ = pbForm++;

return pvTo;

}

九、内存的分配方式

分配方式有三�U�，误��住，说不定那天去面试的时候就会有人问你这问题

1�?静态存储区�Q�是在程序编译时��已�l�分配好的，在整个运行期间都存在�Q�如全局变量、常量�?/FONT>

2�?栈上分配�Q�函数内的局部变量就是从�q�分配的�Q�但分配的内存容易有限�?/FONT>

3�?堆上分配�Q�也�U�动态分配，如我们用new,malloc分配内存�Q�用delete,free来释攄��内存�?/FONT>

十、内存分配的注意事项

用new或malloc分配内存�Ӟ��必须要对此指针赋初倹{�?/FONT>

用delete 或free释放内存后，必须要将指针指向NULL

不能修改指向帔R��的指针数�?/FONT>

十一、内容复制与比较

//数组…�?/FONT>

char a[]=”Hello Word!�?

char b[10];

strcpy(b,a);

if (strcmp(a,b)==0)

{}

//指针…�?/FONT>

char a[]=”Hello Word!�?

char *p;

p=new char[strlen(a)+1];

strcpy(p,a);

if (strcmp(p,a)==0)

{}

十二、sizeof的问�?/FONT>

��C��一点，C++无法知道指针所指对象的大小�Q�指针的大小永远�?字节

char a[]=”Hello World!�?/FONT>

char *p=a;

count sizeof(a) end; //12字节

count sizeof(p) endl; //4字节

而且�Q�在函数中，数组参数退化�ؓ指针�Q�所以下面的内容永远输出�?

void fun(char a[1000])

{

count sizeof(a) endl; //输出4而不�?000

}

十三、关于指�?/FONT>

1�?指针创徏时必��被初始�?/FONT>

2�?指针在free 或delete后必��ȝ��为NULL

3�?指针的长度都�?字节

�Q�、释攑ֆ�存时�Q�如果是数组指针�Q�必��要释放掉所有的内存�Q�如

char *p=new char[100];

strcpy(p,”Hello World�?;

delete []p; //注意前面的��E�Q�号

p=NULL;

�Q�、数�l�指针的内容不能��过数组指针的最大容易�?/FONT>

�?

char *p=new char[5];

strcpy(p,”Hello World�?; //报错目标�Ҏ��不够�?/FONT>

delete []p; //注意前面的��E�Q�号

p=NULL;

十四、关于malloc/free 和new /delete

l malloc/free 是C/C+的内存分配符�Q�new /delete是C++的内存分配符�?/FONT>

l 注意�Q�malloc/free是库函数�Q�new/delete是运��符

l malloc/free不能执行构造函��C��析构函数�Q�而new/delete可以

l new/delete不能在C上运行，所以malloc/free不能被淘�?/FONT>

l 两者都必须要成对��?/FONT>

l C++中可以��用_set_new_hander函数来定义内存分配异常的处理

十五、��E++的特�?/FONT>

�Q?+新增加有重蝲(overload)�Q�内联（inline�Q�，Const�Q�Virtual四种机制

重蝲和内联：卛_��用于全局函数�Q�也可用于类的成员函敎ͼ�

Const和Virtual�Q�只可用于类的成员函敎ͼ�

重蝲�Q�在同一�c�M��Q�函数名相同的函数。由不同的参数决定调用那个函数。函数可要不可要Virtual关键字。和全局函数同名的函��C��叫重载。如果在�c�M��调用同名的全局函数�Q�必��ȝ��全局引用�W�号::引用�?/FONT>

覆盖是指�z��c�d��数覆盖基�c�d��?/FONT>

函数名相同；

参数相同�Q?/FONT>

基类函数必须有Virtual关键字；

不同的范�?�z��c�d��基类)�?/FONT>

隐藏是指�z��c�d��蔽了基类的同名函数相�?/FONT>

1�?函数名相同，但参��C��同，此时不论基类有无Virtual关键字，基类函数��被隐藏�?/FONT>

2�?函数名相同，参数也相同，但基�c�L��Virtual关键�?有就是覆�?�Q�基�c�d��数将被隐藏�?/FONT>

内联�Q�inline关键字必��M��定义体放在一��P��而不是单单放在声明中�?/FONT>

Const�Q�const是constant的羃写，“恒定不变”的意思。被const修饰的东襉K��受到强制保护�Q�可以预防意外的变动�Q�能提高�E�序的健壮性�?/FONT>

1�?参数做输入用的指针型参数�Q�加上const可防止被意外改动�?/FONT>

2�?按值引用的用户�c�d��做输入参数时�Q�最好将按��g��递的改�ؓ引用传递，�q�加上const关键字，目的是�ؓ了提高效率。数据类型�ؓ内部�c�d��的就没必要做�q��g事情�Q�如�Q?/FONT>

��void Func(A a) 改�ؓvoid Func(const A &a)�?/FONT>

而void func(int a)��没必要�Ҏ��void func(const int &a);

3�?�l�返回��gؓ指针�c�d��的函数加上const�Q�会使函数返回��g��能被修改�Q�赋�l�的变量也只能是const型变量。如�Q�函数const char*GetString(void); char *str=GetString()��会出错。而const char *str=GetString()��是正确的�?/FONT>

4�?Const成员函数是指此函��C��内只能调用Const成员变量�Q�提高程序的键壮性。如声明函数 int GetCount(void) const;此函��C��内就只能调用Const成员变量�?/FONT>

Virtual�Q�虚函数�Q�派生类可以覆盖掉的函数�Q�纯虚函敎ͼ�只是个空函数�Q�没有函数实��C��Q?/FONT>

十六、extern“C”有什么作用？

Extern “C”是由��E�Q�＋提供的一个连接交换指定符��P��用于告诉�Q�＋�Q�这�D�代码是�Q�函数。这是因为C++�~�译后库中函数名会变得很长，与C生成的不一��_��造成�Q�＋�Q�不能直接调用C函数�Q�加上extren “c”后�Q�C++��p��直接调用C函数了�?/FONT>

Extern “C”主要��用正规DLL函数的引用和导出 �?在C++包含C函数或C头文件时使用。��用时在前面加上extern “c�?关键字即可�?/FONT>

十七、构造函��C��析构函数

�z��cȝ��构造函数应在初始化表里调用基类的构造函敎ͼ�

�z��c�d��基类的析构函数应加Virtual关键字�?/FONT>

不要��看构造函数和析构函数�Q�其实编��h��q�是不容易�?/FONT>

#include iostream.h>

class Base

{

public:

virtual ~Base() { cout "~Base" endl ; }

};

class Derived : public Base

{

public:

virtual ~Derived() { cout "~Derived" endl ; }

};

void main(void)

{

Base * pB = new Derived; // upcast

delete pB;

}

输出�l�果为：

~Derived

~Base

如果析构函数不�ؓ虚，那么输出�l�果�?/FONT>

~Base

十八�?IFNDEF/#DEFINE/#ENDIF有什么作�?/FONT>

仿止该头文�g被重复引�?/FONT>

��力力力 2005-06-21 13:56 发表评论

教你理解复杂的C/C++声明

��力力力 — Sat, 14 May 2005 02:13:00 GMT
曄��到�q�让你迷惑不解、类��g��int * (* (*fp1) (int) ) [10];�q�样的变量声明吗�Q�本文将由易到难�Q�一步一步教会你如何理解�q�种复杂的C/C++声明�?

　　我们��从每天都能��到的较��单的声明入手�Q�然后逐步加入const修饰�W�和typedef�Q�还有函数指针，最后介�l�一个能够让你准��地理解��M��C/C++声明的“右左法则”�?

　　需要强调一下的是，复杂的C/C++声明�q�不是好的编�E�风��|��我这里仅仅是教你如何�ȝ��解这些声明。注意：��Z��保证能够在同一行上昄��代码和相��x��释，本文最好在臛_��1024x768分��L率的昄��器上阅读�?
　　基础
　　让我们从一个非常简单的例子开始，如下�Q?

　　 int n;

　　�q�个应该被理解�ؓ“declare n as an int”（n是一个int型的变量�Q��?
　　接下��L��看一下指针变量，如下�Q?

　　int *p;

　　�q�个应该被理解�ؓ“declare p as an int *”（p是一个int *型的变量�Q�，或者说p是一个指向一个int型变量的指针。我惛_��q�里展开讨论一下：我觉得在声明一个指针（或引用）�c�d��的变量时�Q�最好将*�Q�或&�Q�写在紧靠变量之前，而不是紧跟基本类型之后。这样可以避免一些理解上的误区，比如�Q?

　　int* p,q;

　　�W�一眼看去，好像是p和q都是int*�c�d��的，但事实上�Q�只有p是一个指针，而q是一个最��单的int型变量�?
　　我们�q�是�l�箋我们前面的话题，再来看一个指针的指针的例子：

　　char **argv;

　　理论上，对于指针的��数没有限�Ӟ��你可以定义一个��Q点类型变量的指针的指针的指针的指�?..
　　再来看如下的声明�Q?

　　int RollNum[30][4];
　　int (*p)[4]=RollNum;
　　int *q[5];

　　�q�里�Q�p被声明�ؓ一个指向一�?元素�Q�int�c�d��Q�数�l�的指针�Q�而q被声明�ؓ一个包�?个元素（int�c�d��的指针）的数�l��?BR>　　另外�Q�我们还可以在同一个声明中混合实用*�?amp;�Q�如下：

　　int **p1; // p1 is a pointer to a pointer to an int.
　　int *&p2; // p2 is a reference to a pointer to an int.
　　int &*p3; // ERROR: Pointer to a reference is illegal.
　　int &&p4; // ERROR: Reference to a reference is illegal.

　　注：p1是一个int�c�d��的指针的指针�Q�p2是一个int�c�d��的指针的引用�Q�p3是一个int�c�d��引用的指针（不合法！�Q�；p4是一个int�c�d��引用的引用（不合法！�Q��?BR>　　const修饰�W?BR>　　当你想阻止一个变量被改变�Q�可能会用到const关键字。在你给一个变量加上const修饰�W�的同时�Q�通常需要对它进行初始化�Q�因��Z��后的��M��时候你��没有机会再��L��变它。例如：

　　const int n=5;
　　int const m=10;

　　上述两个变量n和m其实是同一�U�类型的——都是const int�Q�整形恒量）。因为C++标准规定�Q�const关键字放在类型或变量名之前等��L��。我个�h更喜�Ƣ第一�U�声明方式，因�ؓ它更�H�出了const修饰�W�的作用�?BR>　　当const与指针一起��用时�Q�容易让人感到迷惑。例如，我们来看一下下面的p和q的声明：

　　const int *p;
　　int const *q;

　　他们当中哪一个代表const int�c�d��的指针（const直接修饰int�Q�，哪一个代表int�c�d��的const指针�Q�const直接修饰指针�Q�？实际上，p和q都被声明为const int�c�d��的指针。而int�c�d��的const指针应该�q�样声明�Q?BR>
　　int * const r= &n; // n has been declared as an int

　　 �q�里�Q�p和q都是指向const int�c�d��的指针，也就是说�Q�你在以后的�E�序里不能改�?p的倹{��而r是一个const指针�Q�它在声明的时候被初始化指向变量n�Q�即r=&n;�Q�之后，r的值将不再允许被改变（�?r的值可以改变）�?BR>　　 �l�合上述两种const修饰的情况，我们来声明一个指向const int�c�d��的const指针�Q�如下：

　　const int * const p=&n // n has been declared as const int

　　下面�l�出的一些关于const的声明，��帮助你��d��理清const的用法。不�q�请注意�Q�下面的一些声明是不能被编译通过的，因�ؓ他们需要在声明的同时进行初始化。�ؓ了简�z��v见，我忽略了初始化部分；因�ؓ加入初始化代码的话，下面每个声明都将增加两行代码�?BR>
　　char ** p1; // pointer to pointer to char
　　const char **p2; // pointer to pointer to const char
　　char * const * p3; // pointer to const pointer to char
　　const char * const * p4; // pointer to const pointer to const char
　　char ** const p5; // const pointer to pointer to char
　　const char ** const p6; // const pointer to pointer to const char
　　char * const * const p7; // const pointer to const pointer to char
　　const char * const * const p8; // const pointer to const pointer to const char

　　注：p1是指向char�c�d��的指针的指针�Q�p2是指向const char�c�d��的指针的指针�Q�p3是指向char�c�d��的const指针�Q�p4是指向const char�c�d��的const指针�Q�p5是指向char�c�d��的指针的const指针�Q�p6是指向const char�c�d��的指针的const指针�Q�p7是指向char�c�d��const指针的const指针�Q�p8是指向const char�c�d��的const指针的const指针�?BR>　　typedef的妙�?BR>　　 typedef�l�你一�U�方式来克服�?只适合于变量而不适合于类型”的弊端。你可以如下使用typedef�Q?BR>
　　typedef char * PCHAR;
　　PCHAR p,q;

　　 �q�里的p和q都被声明为指针。（如果不��用typedef�Q�q��被声明��Z��个char变量�Q�这跟我们的�W�一眼感觉不太一��_��Q�下面有一些��用typedef的声明，�q�且�l�出了解释：

　　typedef char * a; // a is a pointer to a char
　　typedef a b(); // b is a function that returns
　　 // a pointer to a char
　　typedef b *c; // c is a pointer to a function
　　 // that returns a pointer to a char
　　typedef c d(); // d is a function returning
　　 // a pointer to a function
　　 // that returns a pointer to a char
　　typedef d *e; // e is a pointer to a function
　　 // returning a pointer to a
　　 // function that returns a
　　 // pointer to a char
　　e var[10]; // var is an array of 10 pointers to
　　 // functions returning pointers to
　　 // functions returning pointers to chars.

　　 typedef�l�常用在一个结构声明之前，如下。这��P��当创建结构变量的时候，允许你不使用关键字struct�Q�在C中，创徏�l�构变量时要求��用struct关键字，如struct tagPOINT a�Q�而在C++中，struct可以忽略�Q�如tagPOINT b�Q��?BR>
　　typedef struct tagPOINT
　　{
　　 int x;
　　 int y;
　　}POINT;
　　POINT p; /* Valid C code */

　　函数指针
　　函数指针可能是最�Ҏ��引�v理解上的困惑的声明。函数指针在DOS时代写TSR�E�序时用得最多；在Win32和X-Windows时代�Q�他们被用在需要回调函数的场合。当�Ӟ��q�有其它很多地方需要用到函数指针：虚函数表�Q�STL中的一些模板，Win NT/2K/XP�pȝ��服务�{�。让我们来看一个函数指针的��单例子：

　　int (*p)(char);

　　 �q�里p被声明�ؓ一个函数指针，�q�个函数带一个char�c�d��的参敎ͼ��q�且有一个int�c�d��的返回倹{��另外，带有两个float�c�d��参数、返回值是char�c�d��的指针的指针的函数指针可以声明如下：

　　char ** (*p)(float, float);

　　那么�Q�带两个char�c�d��的const指针参数、无�q�回值的函数指针又该如何声明呢？参考如下：

　　void * (*a[5])(char * const, char * const);

　　 “右左法则”[重要�Q�！�Q�]
　　The right-left rule: Start reading the declaration from the innermost parentheses, go right, and then go left. When you encounter parentheses, the direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole declaration has been parsed.
　　 �q�是一个简单的法则�Q�但能让你准��理解所有的声明。这个法则运用如下：从最内部的括号开始阅��d��明，向右看，然后向左看。当你碰��C��个括��h��p��转阅�ȝ��方向。括号内的所有内定w��分析完毕��p��出括��L��范围。这��L��l�，直到整个声明都被分析完毕�?BR>　　对上�q�“右左法则”做一个小��的修正�Q�当你第一�ơ开始阅��d��明的时候，你必��M��变量名开始，而不是从最内部的括受��?BR>　　下面�l�合例子来演�C�Z��下“右左法则”的使用�?BR>
　　int * (* (*fp1) (int) ) [10];

　　阅读步骤�Q?BR>　　 1. 从变量名开�?-------------------------------------------- fp1
　　 2. 往右看�Q�什么也没有�Q�碰��C��)�Q�因此往左看�Q�碰��C��? ------ 一个指�?BR>　　 3. 跛_��括号�Q�碰��C��(int) ----------------------------------- 一个带一个int参数的函�?BR>　　 4. 向左看，发现一�? --------------------------------------- �Q�函敎ͼ��q�回一个指�?BR>　　 5. 跛_��括号�Q�向右看�Q�碰到[10] ------------------------------ 一�?0元素的数�l?BR>　　 6. 向左看，发现一�? --------------------------------------- 指针
　　 7. 向左看，发现int ----------------------------------------- int�c�d��
　　 �ȝ��Q�fp1被声明成��Z��个函数的指针的指针的数组�Q�这个数�l�有10个元素，函数的原型�ؓ带一个int�c�d��的参敎ͼ��q�回��gؓ一个指针？
　　再来看一个例子：

　　int *( *( *arr[5])())();

　　阅读步骤�Q?BR>　　 1. 从变量名开�?-------------------------------------------- arr
　　 2. 往右看�Q�发现是一个数�l?---------------------------------- 一�?元素的数�l?BR>　　 3. 向左看，发现一�? --------------------------------------- 指针
　　 4. 跛_��括号�Q�向右看�Q�发�?) -------------------------------- 不带参数的函�?BR>　　 5. 向左看，��到* ------------------------------------------- �Q�函敎ͼ��q�回一个指�?BR>　　 6. 跛_��括号�Q�向叛_��?) ------------------------------------ 不带参数的函�?BR>　　 7. 向左�Q�发�? --------------------------------------------- �Q�函敎ͼ��q�回一个指�?BR>　　 8. �l�箋向左�Q�发现int --------------------------------------- int�c�d��
　　 �ȝ��Q?BR>　　 �q�有更多的例子：

　　float ( * ( *b()) [] )(); // b is a function that returns a
　　 // pointer to an array of pointers
　　 // to functions returning floats.
　　void * ( *c) ( char, int (*)()); // c is a pointer to a function that takes
　　 // two parameters:
　　 // a char and a pointer to a
　　 // function that takes no
　　 // parameters and returns
　　 // an int
　　 // and returns a pointer to void.
　　void ** (*d) (int &,
　　 char **(*)(char *, char **)); // d is a pointer to a function that takes
　　 // two parameters:
　　 // a reference to an int and a pointer
　　 // to a function that takes two parameters:
　　 // a pointer to a char and a pointer
　　 // to a pointer to a char
　　 // and returns a pointer to a pointer
　　 // to a char
　　 // and returns a pointer to a pointer to void
　　float ( * ( * e[10])
　　 (int &) ) [5]; // e is an array of 10 pointers to
　　 // functions that take a single
　　 // reference to an int as an argument
　　 // and return pointers to
　　 // an array of 5 floats.

��力力力 2005-05-14 10:13 发表评论

文�g打开方式	说明
r	打开只能�ȝ��文�g
w	建立供写入的文�g�Q�如果已存在��抹��d��有数�?/td>
a	打开或徏立一个把数据�q�加到文件尾的文�?/td>
r+	打开用于更新数据的文�?/td>
w+	建立用于更新数据的文�Ӟ��如果已存在就抹去原有数据
a+	打开或徏立用于更新数据的文�g�Q�数据追加到文�g��?/td>

色噜噜的亚洲男人的天堂,久久精品亚洲中文字幕无码网站,ww亚洲ww在线观看国产

C/C++ �E�序设计员应聘常见面试试题深入剖�?

c 语言隄���分析整理 (�?

链表3

链表2

链表

��Z���?char** 不能自动转化�?const char** (�?

学习~strtok

C语言嵌入式系�l�编�E�修��g���?性能优化

C语言嵌入式系�l�编�E�修��g���?性能优化

C语言嵌入式系�l�编�E�修��g���?键盘操作

C语言嵌入式系�l�编�E�修��g���?键盘操作

C语言嵌入式系�l�编�E�修��g���?屏幕操作

C语言嵌入式系�l�编�E�修��g���?屏幕操作

C语言嵌入式系�l�编�E�修��g���?内存操作

C语言嵌入式系�l�编�E�修��g���?内存操作

http://www.upsdn.net/(推荐下，感兴���的同志可以看看哈，便携�pȝ��开发网)

修练8�q�C++面向对象�E�序设计之体�?林锐博士)

c++ primer �W�记�Q�名字空��_��

内存���理<�?gt;

说明以下关键字的作用 auto static register const volatile extern

说明以下关键字的作用 (�?

auto static�?/FONT> register const volatile extern

(1)auto

(2)register

(3)static

(4)const

(5)volatile

(6)extern

c++常见问题

教你理解复杂的C/C++声明

c 语言隄��分析整理 (�?

��Z��?char 不能自动转化�?const char (�?

C语言嵌入式系�l�编�E�修��g��?性能优化

C语言嵌入式系�l�编�E�修��g��?性能优化

C语言嵌入式系�l�编�E�修��g��?键盘操作

C语言嵌入式系�l�编�E�修��g��?键盘操作

C语言嵌入式系�l�编�E�修��g��?屏幕操作

C语言嵌入式系�l�编�E�修��g��?屏幕操作

C语言嵌入式系�l�编�E�修��g��?内存操作

C语言嵌入式系�l�编�E�修��g��?内存操作

http://www.upsdn.net/(推荐下，感兴��的同志可以看看哈，便携�pȝ��开发网)

内存��理<�?gt;

auto　　static�?/FONT>　　register　　const 　　volatile 　　extern