西部数码网站建设,网站策划书我与音乐,能自己做网站吗,网站头部ps1. C概述1.1 c简介“c”中的来自于c语言中的递增运算符#xff0c;该运算符将变量加1。c起初也叫”c withclsss”.通过名称表明#xff0c;c是对C的扩展#xff0c;因此c是c语言的超集#xff0c;这意味着任何有效的c程序都是有效的c程序。c程序可以使用已有的c程序库。为什…1. C概述1.1 c简介“c”中的来自于c语言中的递增运算符该运算符将变量加1。c起初也叫”c withclsss”.通过名称表明c是对C的扩展因此c是c语言的超集这意味着任何有效的c程序都是有效的c程序。c程序可以使用已有的c程序库。为什么c不叫c呢因为它虽然对c进行了改进、扩展但是很多人还是把它当做c来使用。c后置,先对c进行扩展但返回的还是c. 库是编程模块的集合可以在程序中调用它们。库对很多常见的编程问题提供了可靠的解决方法因此可以节省程序员大量的时间和工作量。c语言在c语言的基础上添加了面向对象编程和泛型编程的支持。c继承了c语言高效简洁快速和可移植的传统。c融合了3种不同的编程方式:c语言代表的过程性语言.c在c语言基础上添加的类代表的面向对象语言.c模板支持的泛型编程。c语言和c语言的关系:c语言是在C语言的基础上添加了面向对象、模板等现代程序设计语言的特性而发展起来的。两者无论是从语法规则上还是从运算符的数量和使用上都非常相似所以我们常常将这两门语言统称为“C/C”。C语言和C并不是对立的竞争关系C是C语言的加强是一种更好的C语言C是以C语言为基础的并且完全兼容C语言的特性。C语言和C语言的学习是可以相互促进。学好C语言可以为我们将来进一步地学习C语言打好基础而C语言的学习也会促进我们对于C语言的理解从而更好地运用C语言。1.2 c起源与c语言一样c也是在贝尔实验室诞生的Bjarne Stroustrup(本贾尼·斯特劳斯特卢普)在20世纪80年代在这里开发了这种语言。Stroustrup关心的是让c更有用而不是实施特定的编程原理或风格。在确定语言特性方面真正的编程比纯粹的原理更重要。Stroustrup之所以在c的基础上创建c,是因为c语言简洁、适合系统编程、使用广泛且与UNIX操作系统联系紧密。1.3 可移植性和标准假设为运行windows 2000的老式奔腾pc编写了一个很好用的c程序而管理员决定使用不同操作系统(比如说Mac OS 或 Linux)和处理器的计算机替换它。该程序是否可在新平台运行呢当然但是必须使用为新平台设计的c编译器重新编译。但是是否需要修改写好的代码如果不需要修改代码的情况下重新编译程序后程序依然运行良好该程序是可移植的。程序是否可移植性有两个问题需要解决。第一是硬件针对特定硬件编程的程序是不可移植的。第二语言的实现windows xp c 和 Redhat Linux 或 Mac OS X对c的实现不一定相同。虽然我们希望c版本与其他版本兼容但是如果没有一个公开的标准很难做到。因此美国国家标准局(AmericanNational Standards Institute,ANSI)在1990年设立一个委员会专门负责制定c标准(ANSI制定了c语言的标准)。国际标准化组织(International Organization forStandardizationISO)很快通过自己的委员会加入到这个行列创建了联合组织ANSI/ISO,制定c标准。经过多年的努力制定出了一个国际标准ISO/IEC14882:1998 并于1998年获得了ISO、IEC(International ElectrotechnicalCommittee,国际电工技术委员会)和ANSI的批准。这个标准就是我们经常所说的c98。它不仅描述了已有的c特性还对语言进行了扩展添加了异常、运行阶段类型识别(RTTI)、模板和标准模板库(STL).2003年发布了c标准第二版(IOS/IEC 14882:2003),这一版本对第一版修订了一些错误但并没有改变语言特性因此c98表示c98/c2003.c不断发展。IOS标准委员会于2011年8月批准了新标准ISO/IEC 14882:2011,该标准被称为c11,与c98一样c11也新增了许多特性。ISO c标准还吸收了ANSI c语言标准c尽量做到是c的超集。意味着在理想情况下任何有效的c程序都应该是有效的c程序。ANSI不仅定义了c语言还 定义了一个ANSI c必须实现的标准c库。c也在使用这个库另外ANSI/ISOc标准还提供了一个c标准类库。、1.4 为什么C会成功c最初的目的是将c语言转变为OOP语言但是c后来并没有这么做而是立足于程序的实际。因为在c语言方面大量投入的程序员使其完全丢掉c语言那种编程的思考方式转而去接受一种新的语言新的思维那么将会导致这些程序员中大部分人在短时间内可能毫无成果使其生产率降低。但是如果让这些c程序员在已有知识的基础上再去学习c语言理解运用OOP那么也只是在其已有思维的基础上进行扩展而已这样可以保持其更好的生产率。简而言之强迫程序员放弃c语言和c语言的思考方式而去转到OOP上是需要代价的但是从c语言转到c所花费的代价就会小很多。所以也可以理解为c的出现并不是去替代c,而是对c的扩展所以在c中既可以使用c新特性并且可以使用c的过程式思维来编写程序。对于传统的结构化语言我们向来没有太多的疑惑函数调用那么自然而明显只是从程序的某一个地点调到另一个地点去执行。但是对于面向对象(OO)语言我们疑惑就会很多。其原因就是c编译器为我们程序员做了太多隐藏的工作构造函数析构函数、虚函数、继承、多态....有时候它为我们合成出一些额外的函数,有时候它又偷偷在我们写的函数里放进更多的操作。有时候也会给我们的对象里放进一些奇妙的东西使得我们sizeof的时候结果和我们预期不一样。2. C初识2.1 简单的c程序2.1.1 c hello world#define _CRT_SECURE_NO_WARNINGS
#includeiostream
//using namespace std;int main(){cout hello world endl;system(pause);return EXIT_SUCCESS;
}分析:#includeiostream;预编译指令引入头文件iostream.using namespace std; 使用标准命名空间cout “helloworld” endl; 和printf功能一样输出字符串”hello wrold”问题1c头文件为什么没有.h在c语言中头文件使用扩展名.h,将其作为一种通过名称标识文件类型的简单方式。但是c得用法改变了c头文件没有扩展名。但是有些c语言的头文件被转换为c的头文件这些文件被重新命名丢掉了扩展名.h(使之成为c风格头文件)并在文件名称前面加上前缀c(表明来自c语言)。例如c版本的math.h为cmath.由于C使用不同的扩展名来表示不同文件类型因此用一些特殊的扩展名(如hpp或hxx)表示c的头文件也是可以的ANSI/IOS标准委员会也认为是可以的但是关键问题是用哪个比较好最后一致同意不适用任何扩展名。头文件类型约定示例说明c旧式风格以.h结尾iostream.hc程序可用c旧式风格以.h结尾math.hc/c程序可用c新式风格无扩展名iostreamc程序可用使用namespace std转换后的c加上前缀c,无扩展名cmathc程序可用可使用非c特性如namespace std问题2using namespace std 是什么?namespace是指标识符的各种可见范围。命名空间用关键字namespace 来定义。命名空间是C的一种机制用来把单个标识符下的大量有逻辑联系的程序实体组合到一起。此标识符作为此组群的名字。问题3cout 、endl 是什么cout是c中的标准输出流endl是输出换行并刷新缓冲区。2.1.2 面向对象三大特性封装把客观事物封装成抽象的类并且类可以把自己的数据和方法只让可信的类或者对象操作对不可信的进行信息隐藏。类将成员变量和成员函数封装在类的内部根据需要设置访问权限通过成员函数管理内部状态。继承继承所表达的是类之间相关的关系这种关系使得对象可以继承另外一类对象的特征和能力。继承的作用避免公用代码的重复开发减少代码和数据冗余。多态 多态性可以简单地概括为“一个接口多种方法”字面意思为多种形态。程序在运行时才决定调用的函数它是面向对象编程领域的核心概念。3. C对C的扩展3.1 ::作用域运算符通常情况下如果有两个同名变量一个是全局变量另一个是局部变量那么局部变量在其作用域内具有较高的优先权它将屏蔽全局变量。//全局变量
int a 10;
void test(){//局部变量int a 20;//全局a被隐藏cout a: a endl;
}程序的输出结果是a:20。在test函数的输出语句中使用的变量a是test函数内定义的局部变量因此输出的结果为局部变量a的值。作用域运算符可以用来解决局部变量与全局变量的重名问题 //全局变量
int a 10;
//1. 局部变量和全局变量同名
void test(){int a 20;//打印局部变量acout 局部变量a: a endl;//打印全局变量acout 全局变量a: ::a endl;
}这个例子可以看出作用域运算符可以用来解决局部变量与全局变量的重名问题即在局部变量的作用域内可用::对被屏蔽的同名的全局变量进行访问。3.2 名字控制创建名字是程序设计过程中一项最基本的活动当一个项目很大时它会不可避免地包含大量名字。c允许我们对名字的产生和名字的可见性进行控制。我们之前在学习c语言可以通过static关键字来使得名字只得在本编译单元内可见在c中我们将通过一种通过命名空间来控制对名字的访问。3.2.1 C命名空间(namespace)在c中名称name可以是符号常量、变量、函数、结构、枚举、类和对象等等。工程越大名称互相冲突性的可能性越大。另外使用多个厂商的类库时也可能导致名称冲突。为了避免在大规模程序的设计中以及在程序员使用各种各样的C库时这些标识符的命名发生冲突标准C引入关键字namespace命名空间/名字空间/名称空间可以更好地控制标识符的作用域。3.2.2命名空间使用语法创建一个命名空间:namespace A{int a 10;
}
namespace B{int a 20;
}
void test(){cout A::a : A::a endl;cout B::a : B::a endl;
}命名空间只能全局范围内定义以下错误写法void test(){namespace A{int a 10;}namespace B{int a 20;}cout A::a : A::a endl;cout B::a : B::a endl;
}命名空间可嵌套命名空间namespace A{int a 10;namespace B{int a 20;}
}
void test(){cout A::a : A::a endl;cout A::B::a : A::B::a endl;
}命名空间是开放的即可以随时把新的成员加入已有的命名空间中namespace A{int a 10;
}namespace A{void func(){cout hello namespace! endl;}
}void test(){cout A::a : A::a endl;A::func();
}声明和实现可分离:文件test.h#pragma oncenamespace MySpace{void func1();void func2(int param);
}文件test.cppvoid MySpace::func1(){cout MySpace::func1 endl;
}
void MySpace::func2(int param){cout MySpace::func2 : param endl;
}无名命名空间意味着命名空间中的标识符只能在本文件内访问相当于给这个标识符加上了static使得其可以作为内部连接:namespace{int a 10;void func(){ cout hello namespace endl; }
}
void test(){cout a : a endl;func();
}命名空间别名:namespace veryLongName{int a 10;void func(){ cout hello namespace endl; }
}void test(){namespace shortName veryLongName;cout veryLongName::a : shortName::a endl;veryLongName::func();shortName::func();
}3.2.3 using声明using声明可使得指定的标识符可用。namespace A{int paramA 20;int paramB 30;void funcA(){ cout hello funcA endl; }void funcB(){ cout hello funcA endl; }
}void test(){//1. 通过命名空间域运算符cout A::paramA endl;A::funcA();//2. using声明using A::paramA;using A::funcA;cout paramA endl;//cout paramB endl; //不可直接访问funcA();//3. 同名冲突//int paramA 20; //相同作用域注意同名冲突using声明碰到函数重载namespace A{void func(){}void func(int x){}int func(int x,int y){}
}
void test(){using A::func;func();func(10);func(10, 20);
}如果命名空间包含一组用相同名字重载的函数using声明就声明了这个重载函数的所有集合。3.2.4 using编译指令using编译指令使整个命名空间标识符可用。namespace A{int paramA 20;int paramB 30;void funcA(){ cout hello funcA endl; }void funcB(){ cout hello funcB endl; }
}void test01(){using namespace A;cout paramA endl;cout paramB endl;funcA();funcB();//不会产生二义性int paramA 30;cout paramA endl;
}namespace B{int paramA 20;int paramB 30;void funcA(){ cout hello funcA endl; }void funcB(){ cout hello funcB endl; }
}void test02(){using namespace A;using namespace B;//二义性产生不知道调用A还是B的paramA//cout paramA endl;
}注意使用using声明或using编译指令会增加命名冲突的可能性。也就是说如果有名称空间并在代码中使用作用域解析运算符则不会出现二义性。3.2.5 命名空间使用需要记住的关键问题是当引入一个全局的using编译指令时就为该文件打开了该命名空间它不会影响任何其他的文件所以可以在每一个实现文件中调整对命名空间的控制。比如如果发现某一个实现文件中有太多的using指令而产生的命名冲突就要对该文件做个简单的改变通过明确的限定或者using声明来消除名字冲突这样不需要修改其他的实现文件。3.3 struct类型加强C中定义结构体变量需要加上struct关键字c不需要。C中的结构体只能定义成员变量不能定义成员函数。c即可以定义成员变量也可以定义成员函数。//1. 结构体中即可以定义成员变量也可以定义成员函数
struct Student{string mName;int mAge;void setName(string name){ mName name; }void setAge(int age){ mAge age; }void showStudent(){cout Name: mName Age: mAge endl;}
};//2. c中定义结构体变量不需要加struct关键字
void test01(){Student student;student.setName(John);student.setAge(20);student.showStudent();
}3.4 更严格的类型转换在C不同类型的变量一般是不能直接赋值的需要相应的强转。c语言代码typedef enum COLOR{ GREEN, RED, YELLOW } color;int main(){color mycolor GREEN;mycolor 10;printf(mycolor:%d\n, mycolor);char* p malloc(10);return EXIT_SUCCESS;
}以上c代码c编译器编译可通过c编译器无法编译通过。C代码如下char* p (char*)malloc(10);3.5 三目运算符功能增强 左值和右值概念在c中可以放在赋值操作符左边的是左值可以放到赋值操作符右面的是右值。有些变量即可以当左值也可以当右值。左值为LvalueL代表Location表示内存可以寻址可以赋值。右值为RvalueR代表Read,就是可以知道它的值。比如:int temp 10; temp在内存中有地址10没有但是可以Read到它的值。c语言三目运算表达式返回值为数据值为右值不能赋值。 int a 10;int b 20;printf(ret:%d\n, a b ? a : b);//思考一个问题(a b ? a : b) 三目运算表达式返回的是什么//(a b ? a : b) 100;//返回的是右值c语言三目运算表达式返回值为变量本身(引用)为左值可以赋值。 int a 10;int b 20;printf(ret:%d\n, a b ? a : b);//思考一个问题(a b ? a : b) 三目运算表达式返回的是什么cout b: b endl;//返回的是左值变量的引用(a b ? a : b) 100;//返回的是左值变量的引用cout b: b endl;3.6 C/C中的const3.6.1 const概述const单词字面意思为常数不变的。它是c/c中的一个关键字是一个限定符它用来限定一个变量不允许改变它将一个对象转换成一个常量。const int a 10;
A 100; //编译错误,const是一个常量不可修改3.6.2 C/C中const的区别3.6.2.1 C中的const 常量的引进是在c早期版本中当时标准C规范正在制定。那时尽管C委员会决定在C中引入const,但是他们c中的const理解为”一个不能改变的普通变量”也就是认为const应该是一个只读变量既然是变量那么就会给const分配内存并且在c中const是一个全局只读变量c语言中const修饰的只读变量是外部连接的。const int arrSize 10;
int arr[arrSize];看似是一件合理的编码但是这将得出一个错误。因为arrSize占用某块内存所以C编译器不知道它在编译时的值是多少3.6.2.2 C中的const 在c中一个const不必创建内存空间而在c中一个const总是需要一块内存空间。在c中是否为const常量分配内存空间依赖于如何使用。一般说来如果一个const仅仅用来把一个名字用一个值代替(就像使用#define一样)那么该存储局空间就不必创建。如果存储空间没有分配内存的话在进行完数据类型检查后为了代码更加有效值也许会折叠到代码中。不过取一个const地址, 或者把它定义为extern,则会为该const创建内存空间。const前加volatile关键字 禁止优化也会创建内存空间。在c中出现在所有函数之外的const作用于整个文件(也就是说它在该文件外不可见)默认为内部连接c中其他的标识符一般默认为外部连接。3.6.2.3 C/C中const异同总结c语言全局const会被存储到只读数据段。c中全局const当声明extern或者对变量取地址时编译器会分配存储地址变量存储在只读数据段。两个都受到了只读数据段的保护不可修改。const int constA 10;
int main(){int* p (int*)constA;*p 200;
}以上代码在c/c中编译通过在运行期修改constA的值时发生写入错误。原因是修改只读数据段的数据。c语言中局部const存储在堆栈区只是不能通过变量直接修改const只读变量的值但是可以跳过编译器的检查通过指针间接修改const值。 const int constA 10;int* p (int*)constA;*p 300;printf(constA:%d\n,constA);printf(*p:%d\n, *p);运行结果c语言中通过指针间接赋值修改了constA的值。c中对于局部的const变量要区别对待对于基础数据类型也就是const int a 10这种编译器会进行优化将值替换到访问的位置。 const int constA 10;int* p (int*)constA;*p 300;cout constA: constA endl;cout *p: *p endl;运行结果对于基础数据类型如果用一个变量初始化const变量如果const int a b,那么也是会给a分配内存。 int b 10;const int constA b;int* p (int*)constA;*p 300;cout constA: constA endl;cout *p: *p endl;运行结果constA 分配了内存所以我们可以修改constA内存中的值。对于自定数据类型比如类对象那么也会分配内存。 const Person person; //未初始化age//person.age 50; //不可修改Person* pPerson (Person*)person;//指针间接修改pPerson-age 100;cout pPerson-age: pPerson-age endl;pPerson-age 200;cout pPerson-age: pPerson-age endl;运行结果为person分配了内存所以我们可以通过指针的间接赋值修改person对象。c中const默认为外部连接c中const默认为内部连接.当c语言两个文件中都有constint a的时候编译器会报重定义的错误。而在c中则不会因为c中的const默认是内部连接的。如果想让c中的const具有外部连接必须显示声明为: extern const int a 10;const由c采用并加进标准c中尽管他们很不一样。在c中编译器对待const如同对待变量一样只不过带有一个特殊的标记意思是”你不能改变我”。在c中定义const时编译器为它创建空间所以如果在两个不同文件定义多个同名的const链接器将发生链接错误。简而言之,const在c中用的更好。了解: 能否用变量定义数组:在支持c99标准的编译器中可以使用变量定义数组。1. 微软官方描述vs2013编译器不支持c99.MicrosoftC conforms to the standard for the C language as set forth in the 9899:1990 editionof the ANSI C standard. 2. 以下代码在Linux GCC支持c99编译器编译通过int a 10;
int arr[a];
int i 0;
for(;i10;i)arr[i] i;
i 0;
for(;i10;i)printf(%d\n,arr[i]);3.6.3 尽量以const替换#define在旧版本C中如果想建立一个常量必须使用预处理器”#define MAX 1024;// const int max 1024我们定义的宏MAX从未被编译器看到过因为在预处理阶段所有的MAX已经被替换为了1024于是MAX并没有将其加入到符号表中。但我们使用这个常量获得一个编译错误信息时可能会带来一些困惑因为这个信息可能会提到1024但是并没有提到MAX.如果MAX被定义在一个不是你写的头文件中你可能并不知道1024代表什么也许解决这个问题要花费很长时间。解决办法就是用一个常量替换上面的宏。const int max 1024;const和#define区别总结:const有类型可进行编译器类型安全检查。#define无类型不可进行类型检查.const有作用域而#define不重视作用域默认定义处到文件结尾.如果定义在指定作用域下有效的常量那么#define就不能用。1. 宏常量没有类型所以调用了int类型重载的函数。const有类型所以调用希望的short类型函数#define PARAM 128
const short param 128;void func(short a){cout short! endl;
}
void func(int a){cout int endl;
}2. 宏常量不重视作用域.void func1(){const int a 10;#define A 20 //#undef A //卸载宏常量A
}
void func2(){//cout a: a endl; //不可访问超出了const int a作用域cout A: A endl; //#define作用域从定义到文件结束或者到#undef可访问
}
int main(){func2();return EXIT_SUCCESS;
}问题: 宏常量可以有命名空间吗namespace MySpace{#define num 1024
}
void test(){//cout MySpace::NUM endl; //错误//int num 100; //命名冲突cout num endl;
}3.7 引用(reference)3.7.1 引用基本用法引用是c对c的重要扩充。在c/c中指针的作用基本都是一样的但是c增加了另外一种给函数传递地址的途径这就是按引用传递(pass-by-reference)它也存在于其他一些编程语言中并不是c的发明。变量名实质上是一段连续内存空间的别名是一个标号(门牌号)程序中通过变量来申请并命名内存空间通过变量的名字可以使用存储空间对一段连续的内存空间只能取一个别名吗c中新增了引用的概念引用可以作为一个已定义变量的别名。基本语法: Type ref val;注意事项在此不是求地址运算而是起标识作用。类型标识符是指目标变量的类型必须在声明引用变量时进行初始化。引用初始化之后不能改变。不能有NULL引用。必须确保引用是和一块合法的存储单元关联。建立对数组的引用。//1. 认识引用
void test01(){int a 10;//给变量a取一个别名bint b a;cout a: a endl;cout b: b endl;cout ------------ endl;//操作b就相当于操作a本身b 100;cout a: a endl;cout b: b endl;cout ------------ endl;//一个变量可以有n个别名int c a;c 200;cout a: a endl;cout b: b endl;cout c: c endl;cout ------------ endl;//a,b,c的地址都是相同的cout a: a endl;cout b: b endl;cout c: c endl;
}
//2. 使用引用注意事项
void test02(){//1) 引用必须初始化//int ref; //报错:必须初始化引用//2) 引用一旦初始化不能改变引用int a 10;int b 20;int ref a;ref b; //不能改变引用
}建立数组引用方法://1. 建立数组引用方法一
//1、定义数组类型
typedef int (ArrRef)[10];
int arr[10];
//2、建立引用
ArrRef aRef arr;
for (int i 0; i 10;i ){aRef[i] i1;
}
for (int i 0; i 10;i){cout arr[i] ;
}
cout endl;//2. 建立数组引用方法二
int(f)[10] arr; //直接定义引用
for (int i 0; i 10; i){f[i] i10;
}
for (int i 0; i 10; i){cout arr[i] ;
}
cout endl;//3. 建立数组引用方法三
typedef int(ArrRef1)[10];//定义引用数组类型
ArrRef1 aRef1 arr;
for (int i 0; i 10; i){aRef1[i] i10;
}
for (int i 0; i 10; i){cout arr[i] ;
}
cout endl;3.7.2 引用的本质引用的本质在c内部实现是一个常指针.Type ref val; // Type* const ref val;c编译器在编译过程中使用常指针作为引用的内部实现因此引用所占用的空间大小与指针相同只是这个过程是编译器内部实现用户不可见。 //发现是引用转换为 int* const ref a;
void testFunc(int ref){ref 100; // ref是引用转换为*ref 100
}
int main(){int a 10;int aRef a; //自动转换为int* const aRef a;这也能说明引用为什么必须初始化aRef 20; //内部发现aRef是引用自动帮我们转换为: *aRef 20;cout a: a endl;cout aRef: aRef endl;testFunc(a);system(pause);return EXIT_SUCCESS;
}3.7.3 指针引用在c语言中如果想改变一个指针的指向而不是它所指向的内容函数声明可能这样:void fun(int**);给指针变量取一个别名:Type* pointer NULL;
Type* ref pointer;指针间接修改与引用修改对比如下struct Teacher{int mAge;
};
//指针间接修改teacher的年龄
void AllocateAndInitByPointer(Teacher** teacher){*teacher (Teacher*)malloc(sizeof(Teacher));(*teacher)-mAge 200;
}
//引用修改teacher年龄
void AllocateAndInitByReference(Teacher* teacher){teacher-mAge 300;
}
void test(){//创建TeacherTeacher* teacher NULL;//指针间接赋值AllocateAndInitByPointer(teacher);cout AllocateAndInitByPointer: teacher-mAge endl;//引用赋值,将teacher本身传到ChangeAgeByReference函数中AllocateAndInitByReference(teacher);cout AllocateAndInitByReference: teacher-mAge endl;free(teacher);
}对于c中的定义那个语法清晰多了。函数参数变成指针的引用用不着取得指针的地址。3.7.4 常量引用常量引用的定义格式:const Type ref val;常量引用注意字面量不能赋给引用但是可以赋给const引用const修饰的引用不能修改。void test01(){int a 100;const int aRef a; //此时aRef就是a//aRef 200; 不能通过aRef的值a 100; //OKcout a: a endl;cout aRef: aRef endl;
}
void test02(){//不能把一个字面量赋给引用//int ref 100;//但是可以把一个字面量赋给常引用const int ref 100; //int temp 200; const int ret temp;
}3.7.5 引用使用场景常量引用主要用在函数的形参尤其是类的拷贝/复制构造函数。将函数的形参定义为常量引用的好处:引用不产生新的变量减少形参与实参传递时的开销。由于引用可能导致实参随形参改变而改变将其定义为常量引用可以消除这种副作用。//1.引用作为函数参数
void func(int a, int b)
{int sum a b;cout sum sum endl;
}void test01()
{int a 10;int b 20;func(a, b);
}如果希望实参随着形参的改变而改变那么使用一般的引用如果不希望实参随着形参改变那么使用常引用。//const int param防止函数中意外修改数据
void ShowVal(const int param){cout param: param endl;
}引用作为函数的返回值//2.引用作为函数的返回值
int func2()
{int b 10;//注意1不要返回局部变量的引用int p b;return p;
}
int func3()
{static int b 10;return b;
}
void test02()
{int q func2();q 100;cout q endl;func2() 200;cout q endl;
---------上面的代码是错误只是编译器没有检测出来cout func2func2() endl;func3() 100;//注意2如果要函数当左值那么该函数必须返回引用cout func3() func3() endl;
}3.7.5.1 引用使用中注意点最常见看见引用的地方是在函数参数和返回值中。当引用被用作函数参数的时在函数内对任何引用的修改将对还函数外的参数产生改变。当然可以通过传递一个指针来做相同的事情但引用具有更清晰的语法。如果从函数中返回一个引用必须像从函数中返回一个指针一样对待。当函数返回值时引用关联的内存一定要存在。//值传递
void ValueSwap(int m,int n){int temp m;m n;n temp;
}
//地址传递
void PointerSwap(int* m,int* n){int temp *m;*m *n;*n temp;
}
//引用传递
void ReferenceSwap(int m,int n){int temp m;m n;n temp;
}
void test(){int a 10;int b 20;//值传递ValueSwap(a, b);cout a: a b: b endl;//地址传递PointerSwap(a, b);cout a: a b: b endl;//引用传递ReferenceSwap(a, b);cout a: a b: b endl;
}通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单 函数调用时传递的实参不必加“”符 在被调函数中不必在参数前加“*”符引用作为其它变量的别名而存在因此在一些场合可以代替指针。C主张用引用传递取代地址传递的方式因为引用语法容易且不易出错。//返回局部变量引用
int TestFun01(){int a 10; //局部变量return a;
}
//返回静态变量引用
int TestFunc02(){ static int a 20;cout static int a : a endl;return a;
}
int main(){//不能返回局部变量的引用int ret01 TestFun01();//如果函数做左值那么必须返回引用TestFunc02();TestFunc02() 100;TestFunc02();return EXIT_SUCCESS;
}不能返回局部变量的引用。函数当左值必须返回引用。3.8 C和C的区别C语言的结构体不能写函数C可以结构体定义变量时C不需要加struct关键字更加严格的类型检查const修饰的变量C有时没有内存C语言的都有内存三目运算符返回的值不一样引用和C语言的指针功能一样3.9 内联函数(inline function)3.9.1 内联函数的引出c从c中继承的一个重要特征就是效率。假如c的效率明显低于c的效率那么就会有很大的一批程序员不去使用c了。在c中我们经常把一些短并且执行频繁的计算写成宏而不是函数这样做的理由是为了执行效率宏可以避免函数调用的开销这些都由预处理来完成。但是在c出现之后使用预处理宏会出现两个问题第一个在c中也会出现宏看起来像一个函数调用但是会有隐藏一些难以发现的错误。第二个问题是c特有的预处理器不允许访问类的成员也就是说预处理器宏不能用作类类的成员函数。为了保持预处理宏的效率又增加安全性而且还能像一般成员函数那样可以在类里访问自如c引入了内联函数(inline function).内联函数为了继承宏函数的效率没有函数调用时开销然后又可以像普通函数那样可以进行参数返回值类型的安全检查又可以作为成员函数。3.9.2 预处理宏的缺陷预处理器宏存在问题的关键是我们可能认为预处理器的行为和编译器的行为是一样的。当然也是由于宏函数调用和函数调用在外表看起来是一样的因为也容易被混淆。但是其中也会有一些微妙的问题出现:问题一#define ADD(x,y) xy
inline int Add(int x,int y){return x y;
}
void test(){int ret1 ADD(10, 20) * 10; //希望的结果是300int ret2 Add(10, 20) * 10; //希望结果也是300cout ret1: ret1 endl; //210cout ret2: ret2 endl; //300
}问题二#define COMPARE(x,y) ((x) (y) ? (x) : (y))
int Compare(int x,int y){return x y ? x : y;
}
void test02(){int a 1;int b 3;//cout COMPARE(a, b): COMPARE(a, b) endl; // 3cout Compare(int x,int y): Compare(a, b) endl; //2
}问题三:预定义宏函数没有作用域概念无法作为一个类的成员函数也就是说预定义宏没有办法表示类的范围。3.9.3 内联函数3.9.3.1 内联函数基本概念在c中预定义宏的概念是用内联函数来实现的而内联函数本身也是一个真正的函数。内联函数具有普通函数的所有行为。唯一不同之处在于内联函数会在适当的地方像预定义宏一样展开所以不需要函数调用的开销。因此应该不使用宏使用内联函数。在普通函数(非成员函数)函数前面加上inline关键字使之成为内联函数。但是必须注意必须函数体和声明结合在一起否则编译器将它作为普通函数来对待。inline void func(int a);以上写法没有任何效果仅仅是声明函数应该如下方式来做:inline int func(int a){return ;}注意: 编译器将会检查函数参数列表使用是否正确并返回值(进行必要的转换)。这些事预处理器无法完成的。内联函数的确占用空间但是内联函数相对于普通函数的优势只是省去了函数调用时候的压栈跳转返回的开销。我们可以理解为内联函数是以空间换时间。3.9.3.2 类内部的内联函数为了定义内联函数通常必须在函数定义前面放一个inline关键字。但是在类内部定义内联函数时并不是必须的。任何在类内部定义的函数自动成为内联函数。class Person{
public:Person(){ cout 构造函数! endl; }void PrintPerson(){ cout 输出Person! endl; }
}构造函数Person成员函数PrintPerson在类的内部定义自动成为内联函数。3.9.3.3 内联函数和编译器内联函数并不是何时何地都有效为了理解内联函数何时有效应该要知道编译器碰到内联函数会怎么处理对于任何类型的函数编译器会将函数类型(包括函数名字参数类型返回值类型)放入到符号表中。同样当编译器看到内联函数并且对内联函数体进行分析没有发现错误时也会将内联函数放入符号表。当调用一个内联函数的时候编译器首先确保传入参数类型是正确匹配的或者如果类型不正完全匹配但是可以将其转换为正确类型并且返回值在目标表达式里匹配正确类型或者可以转换为目标类型内联函数就会直接替换函数调用这就消除了函数调用的开销。假如内联函数是成员函数对象this指针也会被放入合适位置。类型检查和类型转换、包括在合适位置放入对象this指针这些都是预处理器不能完成的。但是c内联编译会有一些限制以下情况编译器可能考虑不会将函数进行内联编译不能存在任何形式的循环语句不能存在过多的条件判断语句函数体不能过于庞大不能对函数进行取址操作内联仅仅只是给编译器一个建议编译器不一定会接受这种建议如果你没有将函数声明为内联函数那么编译器也可能将此函数做内联编译。一个好的编译器将会内联小的、简单的函数。3.10 函数的默认参数c在声明函数原型的时可为一个或者多个参数指定默认(缺省)的参数值当函数调用的时候如果没有指定这个值编译器会自动用默认值代替。void TestFunc01(int a 10, int b 20){cout a b a b endl;
}
//注意点:
//1. 形参b设置默认参数值那么后面位置的形参c也需要设置默认参数
void TestFunc02(int a,int b 10,int c 10){}
//2. 如果函数声明和函数定义分开函数声明设置了默认参数函数定义不能再设置默认参数
void TestFunc03(int a 0,int b 0);
void TestFunc03(int a, int b){}int main(){//1.如果没有传参数那么使用默认参数TestFunc01();//2. 如果传一个参数那么第二个参数使用默认参数TestFunc01(100);//3. 如果传入两个参数那么两个参数都使用我们传入的参数TestFunc01(100, 200);return EXIT_SUCCESS;
}注意点函数的默认参数从左向右如果一个参数设置了默认参数那么这个参数之后的参数都必须设置默认参数。如果函数声明和函数定义分开写函数声明和函数定义不能同时设置默认参数。3.11 函数的占位参数c在声明函数时可以设置占位参数。占位参数只有参数类型声明而没有参数名声明。一般情况下在函数体内部无法使用占位参数。void TestFunc01(int a,int b,int){//函数内部无法使用占位参数cout a b a b endl;
}
//占位参数也可以设置默认值
void TestFunc02(int a, int b, int 20){//函数内部依旧无法使用占位参数cout a b a b endl;
}
int main(){//错误调用占位参数也是参数必须传参数//TestFunc01(10,20); //正确调用TestFunc01(10,20,30);//正确调用TestFunc02(10,20);//正确调用TestFunc02(10, 20, 30);return EXIT_SUCCESS;
}什么时候用在后面要讲的操作符重载的区分前置或 后置要用到这个.3.12 函数重载(overload)3.12.1 函数重载概述在传统c语言中函数名必须是唯一的程序中不允许出现同名的函数。在c中是允许出现同名的函数这种现象称为函数重载。函数重载的目的就是为了方便的使用函数名。3.12.2 基本语法实现函数重载的条件同一个作用域参数个数不同参数类型不同参数顺序不同//1. 函数重载条件
namespace A{void MyFunc(){ cout 无参数! endl; }void MyFunc(int a){ cout a: a endl; }void MyFunc(string b){ cout b: b endl; }void MyFunc(int a, string b){ cout a: a b: b endl;}void MyFunc(string b, int a){cout a: a b: b endl;}
}
//2.返回值不作为函数重载依据
namespace B{void MyFunc(string b, int a){}//int MyFunc(string b, int a){} //无法重载仅按返回值区分的函数
}注意: 函数重载和默认参数一起使用需要额外注意二义性问题的产生。void MyFunc(string b){cout b: b endl;
}
//函数重载碰上默认参数
void MyFunc(string b, int a 10){cout a: a b: b endl;
}
int main(){MyFunc(hello); //这时两个函数都能匹配调用产生二义性return 0;
}思考为什么函数返回值不作为重载条件呢 当编译器能从上下文中确定唯一的函数的时如int ret func(),这个当然是没有问题的。然而我们在编写程序过程中可以忽略他的返回值。那么这个时候,假如一个函数为void func(int x);另一个为int func(int x); 当我们直接调用func(10),这个时候编译器就不确定调用那个函数。所以在c中禁止使用返回值作为重载的条件。3.12.3 函数重载实现原理编译器为了实现函数重载也是默认为我们做了一些幕后的工作编译器用不同的参数类型来修饰不同的函数名比如void func(); 编译器可能会将函数名修饰成_func当编译器碰到void func(int x),编译器可能将函数名修饰为func_int,当编译器碰到void func(int x,char c),编译器可能会将函数名修饰为_func_int_char我这里使用”可能”这个字眼是因为编译器如何修饰重载的函数名称并没有一个统一的标准所以不同的编译器可能会产生不同的内部名。void func(){}
void func(int x){}
void func(int x,char y){}
// 以上三个函数在linux下生成的编译之后的函数名为:
_Z4funcv //v 代表void,无参数
_Z4funci //i 代表参数为int类型
_Z4funcic //i 代表第一个参数为int类型第二个参数为char类型3.12.4 extern “C”浅析以下在Linux下测试:c函数: void MyFunc(){} ,被编译成函数: MyFuncc函数: voidMyFunc(){},被编译成函数: _Z6Myfuncv通过这个测试由于c中需要支持函数重载所以c和c中对同一个函数经过编译后生成的函数名是不相同的这就导致了一个问题如果在c中调用一个使用c语言编写模块中的某个函数那么c是根据c的名称修饰方式来查找并链接这个函数那么就会发生链接错误以上例c中调用MyFunc函数在链接阶段会去找Z6Myfuncv结果是没有找到的因为这个MyFunc函数是c语言编写的生成的符号是MyFunc。那么如果我想在c调用c的函数怎么办externC的主要作用就是为了实现c代码能够调用其他c语言代码。加上extern C后这部分代码编译器按c语言的方式进行编译和链接而不是按c的方式。MyModule.h#ifndef MYMODULE_H
#define MYMODULE_H#includestdio.h//这是告诉C编译器找下面的函数要以C语言的方式去寻找
#ifdef __cplusplus
extern C{
#endif//C语言的函数声明void func1();int func2(int a,int b);#ifdef __cplusplus
}
#endif#endifMyModule.c#includeMyModule.hvoid func1(){printf(hello world!);
}
int func2(int a, int b){return a b;
}TestExternC.cpp#define _CRT_SECURE_NO_WARNINGS
#includeiostream
using namespace std;#if 0#ifdef __cplusplusextern C {#if 0void func1();int func2(int a, int b);#else#includeMyModule.h#endif}#endif#elseextern C void func1();extern C int func2(int a, int b);#endifint main(){func1();cout func2(10, 20) endl;return EXIT_SUCCESS;
}
