c语言中知识点.docx
《c语言中知识点.docx》由会员分享，可在线阅读，更多相关《c语言中知识点.docx（13页珍藏版）》请在冰豆网上搜索。
c语言中知识点
1）字符串常量与字符常量的区别：
常量就是固定不变的量，不能通过函数进行修改的变量；变量是可以通过赋值，函数等手段进行修改的一个变量。
字符串常量：
char*a="helloworld";首先，操作系统在编译器规划内存方案中的的文字常量区分配一段内存,存储"helloworld"字符串，然后在栈区分配一个内存，存储"helloworld"字符串所在内存的首地址，字符串常量一旦分配是不允许修改的。
字符常量：
charb[]="helloworld";操作系统在编译器规划的内存方案中的栈区分配一段连续内存空间（12个字节），存储"helloworld"字符串，字符串常量就相当于字符的一个数组，是可以修改的。
2）typedef和#define的区别：
1.基本解释
typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。
这里的数据类型包括内部数据类型（int,char等）和自定义的数据类型（struct等）。
在编程中使用typedef目的一般有两个，一个是给变量一个易记且意义明确的新名字，另一个是简化一些比较复杂的类型声明。
至于typedef有什么微妙之处，请你接着看下面对几个问题的具体阐述。
2.typedef&结构的问题
当用下面的代码定义一个结构时，编译器报了一个错误，为什么呢？
莫非C语言不允许在结构中包含指向它自己的指针吗？
请你先猜想一下，然后看下文说明：
typedefstructtagNode
{
char*pItem;
pNodepNext;
}*pNode;
答案与分析：
1、typedef的最简单使用
typedeflongbyte_4;
给已知数据类型long起个新名字，叫byte_4。
2、typedef与结构结合使用
typedefstructtagMyStruct
{
intiNum;
longlLength;
}MyStruct;
这语句实际上完成两个操作：
1）定义一个新的结构类型
structtagMyStruct
{
intiNum;
longlLength;
};
分析：
tagMyStruct称为“tag”，即“标签”，实际上是一个临时名字，struct关键字和tagMyStruct一起，构成了这个结构类型，不论是否有typedef，这个结构都存在。
我们可以用structtagMyStructvarName来定义变量，但要注意，使用tagMyStructvarName来定义变量是不对的，因为struct和tagMyStruct合在一起才能表示一个结构类型。
2）typedef为这个新的结构起了一个名字，叫MyStruct。
typedefstructtagMyStructMyStruct;
因此，MyStruct实际上相当于structtagMyStruct，我们可以使用MyStructvarName来定义变量。
答案与分析
C语言当然允许在结构中包含指向它自己的指针，我们可以在建立链表等数据结构的实现上看到无数这样的例子，上述代码的根本问题在于typedef的应用。
根据我们上面的阐述可以知道：
新结构建立的过程中遇到了pNext域的声明，类型是pNode，要知道pNode表示的是类型的新名字，那么在类型本身还没有建立完成的时候，这个类型的新名字也还不存在，也就是说这个时候编译器根本不认识pNode。
解决这个问题的方法有多种：
1）、
typedefstructtagNode
{
char*pItem;
structtagNode*pNext;
}*pNode;
2）、
typedefstructtagNode*pNode;
structtagNode
{
char*pItem;
pNodepNext;
};
注意：
在这个例子中，你用typedef给一个还未完全声明的类型起新名字。
C语言编译器支持这种做法。
3）、规范做法：
structtagNode
{
char*pItem;
structtagNode*pNext;
};
typedefstructtagNode*pNode;
3.typedef&#define的问题
有下面两种定义pStr数据类型的方法，两者有什么不同？
哪一种更好一点？
typedefchar*pStr;
#definepStrchar*;
答案与分析：
通常讲，typedef要比#define要好，特别是在有指针的场合。
请看例子：
typedefchar*pStr1;
#definepStr2char*;
pStr1s1,s2;
pStr2s3,s4;
在上述的变量定义中，s1、s2、s3都被定义为char*，而s4则定义成了char，不是我们所预期的指针变量，根本原因就在于#define只是简单的字符串替换而typedef则是为一个类型起新名字。
#define用法例子：
#definef（x）x*x
main（）
{
inta=6，b=2，c；
c=f（a）/f（b）；
printf（"%d"，c）；
}
以下程序的输出结果是:
36。
因为如此原因，在许多C语言编程规范中提到使用#define定义时，如果定义中包含表达式，必须使用括号，则上述定义应该如下定义才对：
#definef（x）（x*x）
当然，如果你使用typedef就没有这样的问题。
4.typedef&#define的另一例
下面的代码中编译器会报一个错误，你知道是哪个语句错了吗？
typedefchar*pStr;
charstring[4]="abc";
constchar*p1=string;
constpStrp2=string;
p1++;
p2++;
答案与分析：
是p2++出错了。
这个问题再一次提醒我们：
typedef和#define不同，它不是简单的文本替换。
上述代码中constpStrp2并不等于constchar*p2。
constpStrp2和constlongx本质上没有区别，都是对变量进行只读限制，只不过此处变量p2的数据类型是我们自己定义的而不是系统固有类型而已。
因此，constpStrp2的含义是：
限定数据类型为char*的变量p2为只读，因此p2++错误。
（注：
关于const的限定内容问题，在本系列第二篇有详细讲解）。
#define与typedef引申谈
1）#define宏定义有一个特别的长处：
可以使用#ifdef,#ifndef等来进行逻辑判断，还可以使用#undef来取消定义。
2）typedef也有一个特别的长处：
它符合范围规则，使用typedef定义的变量类型其作用范围限制在所定义的函数或者文件内（取决于此变量定义的位置），而宏定义则没有这种特性。
5.typedef&复杂的变量声明
在编程实践中，尤其是看别人代码的时候，常常会遇到比较复杂的变量声明,使用typedef作简化自有其价值，比如：
下面是三个变量的声明，我想使用typdef分别给它们定义一个别名，请问该如何做？
>1：
int*（*a[5]）（int,char*）;
>2：
void（*b[10]）（void（*）（））;
>3.doube（*）（）（*pa）[9];
答案与分析：
对复杂变量建立一个类型别名的方法很简单，你只要在传统的变量声明表达式里用类型名替代变量名，然后把关键字typedef加在该语句的开头就行了。
（注：
如果你对有些变量的声明语法感到难以理解，请参阅本系列第十篇的相关内容）。
>1：
int*（*a[5]）（int,char*）;
//pFun是我们建的一个类型别名
typedefint*（*pFun）（int,char*）;
//使用定义的新类型来声明对象，等价于int*（*a[5]）（int,char*）;
pFuna[5];
>2：
void（*b[10]）（void（*）（））;
//首先为上面表达式蓝色部分声明一个新类型
typedefvoid（*pFunParam）（）;
//整体声明一个新类型
typedefvoid（*pFun）（pFunParam）;
//使用定义的新类型来声明对象，等价于void（*b[10]）（void（*）（））;
pFunb[10];
>3.doube（*）（）（*pa）[9];
//首先为上面表达式蓝色部分声明一个新类型
typedefdouble（*pFun）（）;
//整体声明一个新类型
typedefpFun（*pFunParam）[9];
//使用定义的新类型来声明对象，等价于doube（*）（）（*pa）[9];
pFunParampa;
//第1篇:
typedef语句格式
#include
typedefintGTYPE;//定义全局类型GTYPE
voidmain（）
{
//一、基本格式
typedefcharCH;//重定义基本类型
typedefstruct{inta,b,c;}STRU;//重定义自定义类型（结构、共用、枚举）
typedefunion{inta,b,c;}UNIO;
typedefenum{one,two,three}NUM;
typedefchar*STR;//重定义派生类型（指针、数组、函数）
typedefintAI[10];
typedefvoidFUN（void）;
//可见，typedef使用的格式为：
typedef变量/函数定义语句；即在原变量/函数定义语句的开头加上
//typedef，便可将原变量/函数定义语句改写为类型定义语句，原来定义的变量名/函数名都成了类型名。
//注：
当重定义基本、自定义类型时，格式也可总结为：
typedef原类型新类型1,新类型2,…；
//二、观察原类型
//1.原类型可以带有类型限定符
typedefconstintCI;//原类型含const限定符
CIci=3;
//ci=4;//可见CI确实代表constint
//2.原类型可以是typedef定义的新类型
typedefCHNEWCH;//CH已在前面定义为char
NEWCHnc='a';
//3.原类型不可带有存储类别
//typedefstaticintSI;//错误，"指定的存储类多于1个"
//typedefregisterintRI;//错误同上
//4.原类型应是一种类型，而不可是变量/对象
floatf=0;//将f定义为变量
//typedeffFL;//错误
//5.不宜重定义的类型
typedefconstCON;//重定义const
//CONinta=0;//但该类型无法正常使用
typedefunsignedUS;//重定义unsigned
USus1=0;//正确，相当于unsignedint
//USintus2;//错误，无法正常使用
//注：
因const、unsigned等并不是一种独立的类型，故不便对它们重定义
//三、观察新类型
//1.新类型的作用域
typedefintLTYPE;//定义局部类型LTYPE
voidfun（）;//观察LTYPE在fun中是否有效
fun（）;
//可见，用typedef定义的类型也有作用域之分。
在函数内用typedef定义的是局部类型
//typedef也可以像变量定义语句一样放置在函数之外，这时定义的是全局类型
//2.新类型可否是已有类型
//typedefintfloat;//错误，不能重定义标准类型
typedefintTYPE;//定义了新类型TYPE
//typedefcharTYPE;//错误，"TYPE重定义"
typedefintGTYPE;//正确，尽管GTYPE是已有类型，但它是本函数外定义的
//可见，新类型名必须是合法的标识符，它在其作用域内必须是唯一的
//3.新类型可否不止一个
typedeffloatLENGTH,WIDTH;//对float取两个别名，LENGTH和WIDTH
LENGTHL=0;//用新类型定义变量
WIDTHW=0;
//可见，可以一次性为某个原类型指定多个别名
//4.一次可否定义多个不同类型
//typedefintI,floatF;//一次定义了二个不同类型I和F
//Fv=6.0;//试图使用F类型
//printf（"v=%f",v）;//v=0,类型F无效
//可见，一条typedef语句只宜为一个原类型定义别名
}
voidfun（）
{//LTYPEi;//错误，"LTYPE:
未定义的标识符"
GTYPEg=1;//使用全局类型GTYPE
printf（"g=%d",g）;//正常使用
}
//第2篇:
typedef详细使用
#include
#include
voidmain（）
{
//一、重定义基本类型
//1.定义
typedefintin;
typedefcharch;
typedeffloatfl;
typedefdoubledb;
typedefunsignedintui;//或写为typedefunsignedui;
typedefunsignedcharuc;
typedefvoidvo;
//2.使用
ini=3;printf（"i=%d",i）;//用新类型定义变量
ch*pc="pc";printf（"pc=%s",pc）;//用新类型定义指针
flaf[3]={1,2,3};printf（"af[0]=%f",af[0]）;//用新类型定义数组
staticdoublesd;printf（"sd=%f",sd）;//用新类型定义带存储类别的变量
constuicui=3;printf（"cui=%d",cui）;//用新类型定义带类型限定符的变量
vofun1（uc）;fun1（'a'）;//用新类型作函数的参数和返回值类型
printf（"in（1.5）=%d",in（1.5））;//将新类型用作类型转换
printf（"$db=%d",sizeof（db））;//对新类型求长度，$db=$double=8
//二、重定义自定义类型
//1.定义
//
（1）完整写法（先定义好自定义类型，再重定义它）
structdatetype//重定义结构类型
{uiyear;//ui即是unsignedint;
ucmonth;//uc即是unsignedchar;
ucday;};
typedefdatetypedate;
unionscoretype//重定义共用类型
{flsco1;
ch*sco2;};
typedefscoretypescore;
enumnumtype{one,two,three};//重定义枚举类型
typedefnumtypenum;
typedefnumnewnum;//重定义typedef类型
//
（2）通常写法（对无类型名的结构、共用、枚举定义语句直接重定义）
typedefstruct{uchou,min,sec;}time;
typedefunion{flsco1;ch*sco2;}sco;
typedefenum{red,green,blue}color;
//可见，无论何种写法，都遵循typedef语句的格式：
typedef原类型新类型;
//2.使用
datevs={2002,10,15};//定义结构变量
printf（"vs:
%d.%d.%d",vs.year,vs.month,vs.day）;
scorevu,*pu=&vu;printf（"&vu=%xpu=%x",&vu,pu）;//定义共用指针
newnumae[3]={one,two,three};//定义枚举数组
printf（"ae[0]=%dae[1]=%dae[2]=%d",ae[0],ae[1],ae[2]）;
staticnumvn;//定义带存储类别的对象
printf（"vn=%d",vn）;
constscocs={90};//定义const对象
printf（"cs.sco1=%f",cs.sco1）;
timefun2（time）;//作函数的参数和返回值类型
statictimevt=fun2（vt）;
printf（"fun2:
%d:
%d:
%d",vt.hou,vt.min,vt.sec）;
vn=（num）10;printf（"vn=%d",vn）;//将新类型用作类型转换
printf（"$time=%d",sizeof（time））;//对新类型求长度，$time=3
printf（"$sco=%d",sizeof（sco））;//对新类型求长度，$sco=4
printf（"$color=%d",sizeof（color））;//对新类型求长度，$color=4
//第3篇:
typedef具体应用
#include
intfun1（inta,intb）{return0;}
intfun2（inta,intb）{return0;}
intfun3（inta,intb）{return0;}
voidmain（）
{//一、使用typedef的优点
//1可以为现有类型取一个更有意义的名字，增加程序的可读性，如
typedefchar*STRING;
STRINGs1="string1",s2="string2";//STRING便可当作字符串类型来使用
//2使变量定义更简短，减少书写麻烦，如
typedeffloatA3[2][3][4];//为2*3*4的实型数组取简短的名字A3
A3a,b,c;//相当于定义floata[2][3][4],b[2][3][4],c[2][3][4]
typedefunsignedint（*PFUN）（int（*）[4]）;//PFUN是一种函数指针，该类函数参数为一维数组型指针，返回值为无符号整型
PFUNpf1,pf2;//相当于定义unsignedint（*pf1）（int（*）[4]）;unsignedint（*pf2）（int（*）[4]）
//3在定义复杂类型前，先用typedef建立一些中间类型，再用中间类型去构造复杂类型，以降低其复杂性（主要用途）
//例：
对于如下的复杂定义
int（*ap[3]）（int,int）;//ap是一个数组，其元素为函数型指针，该类函数的参数和返回值都是整型
//采用typedef以降低定义难度
//方法1
typedefint（*PF）（int,int）;//定义PF为该种函数的指针
PFap1[3];//ap1为一数组，每个元素都是PF类型
ap1[0]=fun1;ap1[1]=fun2;ap1[2]=fun3;
//方法2
typedefintFUN（int,int）;//将该种函数定义为FUN类型
FUN*ap2[3];//ap2为一数组，每个元素都是指向FUN的指针
ap2[0]=fun1;ap2[1]=fun2;ap2[2]=fun3;
//4增加程序的可移植性（有利于程序在不同处理器、操作系统和编译系统之间的移植）
//二、typedef与define的区别
//用define也可实现简单的类型替换，如
#defineINTlong//用INT来代替long
//两种方式的区别如下：
//1.二者处理时间不同，宏替换是在预编译时进行的，而类型定义是在正式编译时处理的
//2二者本质不同，宏替换只是将宏名简单替换为目标字符串，而类型定义如同定义变量一样
//是真的为程序增加了一种可用类型
//3.二者复杂性不同，用typedef可定义各种复杂的类型，并以各种方式使用新类型（详见10_10_2.cpp）
//而define只能替换基本类型和自定义类型，无法替换派生类型，且使用起来很不安全，例如
#definepiint*//试图用pi代替整型指针
pipi1;//正确，展开后为int*pi1;
pipi2,pi3;//错误，原意是将pi2,pi3都定义成整型指针，但展开后为int*pi2,pi3;pi3并未定义成指针
#defineNUMenum{one,two,three}//试图用NUM代替该枚举类型
NUMn1;//正确，定义了枚举常量one,two,three和枚举变量n1
//NUMn2;//错误，展开后为enum{one,two,three}n2;从而造成枚举常量one,two,three的重定义
#defineDATEstruct{inty,m,d;}
DATE*pd;//正确，定义了该结构型指针
//pd=（DATE）1;//错误，展开后为pi=（struct{inty,m,d;}）1;目前尚不支持此种类型转换写法
#defineTIMEunion{inth,m,s;}
//intL=sizeof（TIME）;//错误，展开后为intL=sizeof（union{inth,m,s;}）;sizeof操作数错误
//可见，用define进行类型替换时，会产生各种意想不到的错误，故应避免使用，而改用安全的typedef
}
升级会员 