c++入门

1. C++关键字
2. 命名空间
3. C++输入&输出
4. 缺省参数
5. 函数重载
6. 引用
7. 内联函数
8. auto关键字(C++11)
9. 基于范围的for循环(C++11)
10. 指针1. C++关键字(C++98)

11.空值---nullptr(C++11)

1.C++总计63个关键字，C语言32个关键字

2.命名空间

1.在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作
用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字
污染，namespace关键字的出现就是针对这种问题的。

2. 命名空间定义
定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名
空间的成员。

//1. 普通的命名空间
namespace N1 // N1为命名空间的名称
{
// 命名空间中的内容，既可以定义变量，也可以定义函数
int a;
int Add(int left, int right)
{
return left + right;
}
}
//2. 命名空间可以嵌套
namespace N2
{
int a;
int b;
int Add(int left, int right)
{
return left + right;
}
namespace N3
{
int c;
int d;
int Sub(int left, int right)
{
return left - right;
}
}
}
//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
namespace N1
{
int Mul(int left, int right)
{
return left * right;
}
}

3. C++输入&输出

新生婴儿会以自己独特的方式向这个崭新的世界打招呼，C++刚出来后，也算是一个新事物，

        

那C++是否也应该向这个美好的世界来声问候呢？我们来看下C++是如何来实现问候的

#include<iostream>
using namespace std;
int main()
{
 cout<<"Hello world!!!"<<endl;
 return 0; }

说明：

1. 使用 cout 标准输出 ( 控制台 ) 和 cin 标准输入 ( 键盘 ) 时，必须 包含 < iostream > 头文件 以及 std 标准命名空

间。

注意：早期标准库将所有功能在全局域中实现，声明在 .h 后缀的头文件中，使用时只需包含对应头文件

即可，后来将其实现在 std 命名空间下，为了和 C 头文件区分，也为了正确使用命名空间，规定 C++ 头文

件不带 .h ；旧编译器 (vc 6.0) 中还支持 <iostream.h> 格式，后续编译器已不支持，因此 推荐 使用

<iostream>+std 的方式。

2. 使用 C++ 输入输

出更方便，不需增加数据格式控制，比如：整形 --%d ，字符 --%c

#include <iostream>
using namespace std;
int main()
{
 int a;
 double b;
 char c;
 
 cin>>a;
 cin>>b>>c;
 
 cout<<a<<endl;
 cout<<b<<" "<<c<<endl;
 return 0; }
void TestFunc(int a = 0) {
 cout<<a<<endl; }
int main()
{
 TestFunc(); // 没有传参时，使用参数的默认值
 TestFunc(10); // 传参时，使用指定的实参
}

4. 缺省参数

大家知道什么是备胎吗？

C++中函数的参数也可以配备胎。

4.1 缺省参数概念

缺省参数是 声明或定义函数时 为函数的 参数指定一个默认值 。在调用该函数时，如果没有指定实参则采用该

默认值，否则使用指定的实参

void TestFunc(int a = 0) {
 cout<<a<<endl; }
int main()
{
 TestFunc(); // 没有传参时，使用参数的默认值
 TestFunc(10); // 传参时，使用指定的实参
}

4.2 缺省参数分类

全缺省参数

void TestFunc(int a = 10, int b = 20, int c = 30) {
 cout<<"a = "<<a<<endl;
 cout<<"b = "<<b<<endl;
 cout<<"c = "<<c<<endl; }

半缺省参数

void TestFunc(int a, int b = 10, int c = 20) {
 cout<<"a = "<<a<<endl;
 cout<<"b = "<<b<<endl;
 cout<<"c = "<<c<<endl; }

注意：

1. 半缺省参数必须 从右往左依次 来给出，不能间隔着给

2. 缺省参数不能在函数声明和定义中同时出现

//a.h
void TestFunc(int a = 10);
// a.c
void TestFunc(int a = 20)
{}
// 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那
个缺省值。

3. 缺省值必须是常量或者全局变量

4. C 语言不支持（编译器不支持)

5. 函数重载

自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该词被重载了。

比如：以前有一个笑话，国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个是男足。前

者是“谁也赢不了！”，后者是“谁也赢不了！”

5.1 函数重载概念

函数重载 : 是函数的一种特殊情况， C++ 允许在 同一作用域中 声明几个功能类似 的同名函数 ，这些同名函数的

形参列表 ( 参数个数 或 类型 或 顺序 ) 必须不同，常用来处理实现功能类似数据类型不同的问题     

int Add(int left, int right) 
{
 return left+right; 
}
double Add(double left, double right) 
{
 return left+right; 
}
long Add(long left, long right) 
{
 return left+right; 
}
int main()
{
 Add(10, 20);
 Add(10.0, 20.0);
 Add(10L, 20L);
 
 return 0; 
}

    

下面两个函数属于函数重载吗？

short Add(short left, short right) {
 return left+right; }
int Add(short left, short right) {
 return left+right; }

返回值不能构成重载

5.2 名字修饰(name Mangling）

为什么 C++ 支持函数重载，而 C 语言不支持函数重载呢？

在 C/C++ 中，一个程序要运行起来，需要经历以下几个阶段： 预处理、编译、汇编、链接 。

 

 

 

1. 实际我们的项目通常是由多个头文件和多个源文件构成，而通过我们 C 语言阶段学习的编译链接，我们

可以知道，【当前 a.cpp 中调用了 b.cpp 中定义的 Add 函数时】，编译后链接前， a.o 的目标文件中没有

Add 的函数地址，因为 Add 是在 b.cpp 中定义的，所以 Add 的地址在 b.o 中。那么怎么办呢？

2. 所以链接阶段就是专门处理这种问题， 链接器看到 a.o 调用 Add ，但是没有 Add 的地址，就会到 b.o 的符

号表中找 Add 的地址，然后链接到一起 。 ( 如果同学们忘记了上面过程，咋们老师要带同学们回顾一下 )

3. 那么链接时，面对 Add 函数，连接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规

则。

4. 由于 Windows 下 vs 的修饰规则过于复杂，而 Linux 下 gcc 的修饰规则简单易懂，下面我们使用了 gcc 演示

了这个修饰后的名字。

5. 通过下面我们可以看出 gcc 的函数修饰后名字不变。而 g++ 的函数修饰后变成【 _Z+ 函数长度 + 函数名 + 类 型首字母】。

采用C语言编译器编译后结果

 结论：在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。

采用C++编译器编译后结果

结论： 在 linux 下，采用 g++ 编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息

添加到修改后的名字中。

6. 通过这里就理解了 C 语言没办法支持重载，因为同名函数没办法区分。而 C++ 是通过函数修饰规则来区

分，只要参数不同，修饰出来的名字就不一样，就支持了重载 。

7. 另外我们也理解了，为什么函数重载要求参数不同！而跟返回值没关系

5.3 extern “C”

有时候在 C++ 工程中可能需要 将某些函数按照 C 的风格来编译 ， 在函数前加 extern "C" ，意思是告诉编译器，

将该函数按照 C 语言规则来编译 。比如： tcmalloc 是 google 用 C++ 实现的一个项目，他提供 tcmallc() 和 tcfree

两个接口来使用，但如果是 C 项目就没办法使用，那么他就使用 extern “C” 来解决

extern "C" int Add(int left, int right);
int main()
{
 Add(1,2);
 return 0; }

链接时报错： error LNK2019: 无法解析的外部符号 _Add ，该符号在函数 _main 中被引用

 6. 引用

6.1 引用概念

引用 不是新定义一个变量，而 是给已存在变量取了一个别名 ，编译器不会为引用变量开辟内存空间，它和它

引用的变量 共用同一块内存空间。

比如： 李逵 ，在家称为 " 铁牛 " ，江湖上人称 " 黑旋风 "。

类型 & 引用变量名 ( 对象名 ) = 引用实体

void TestRef()
{
 int a = 10;
 int& ra = a;//<====定义引用类型
 
 printf("%p\n", &a);
 printf("%p\n", &ra);
}

注意：引用类型必须和引用实体是同种类型的

6.2 引用特性

1. 引用在 定义时必须初始化

2. 一个变量可以有多个引用

3. 引用一旦引用一个实体，再不能引用其他实体

void TestRef()
{
 int a = 10;
 // int& ra; // 该条语句编译时会出错
 int& ra = a;
 int& rra = a;
 printf("%p %p %p\n", &a, &ra, &rra); 
}

6.3 常引用

void TestConstRef()
{
 const int a = 10;
 //int& ra = a; // 该语句编译时会出错，a为常量
 const int& ra = a;
 // int& b = 10; // 该语句编译时会出错，b为常量
 const int& b = 10;
 double d = 12.34;
 //int& rd = d; // 该语句编译时会出错，类型不同
 const int& rd = d; }

6.4 使用场景

1. 做参数

void Swap(int& left, int& right) {
 int temp = left;
 left = right;
 right = temp; }

2. 做返回值

int& Count()
{
 static int n = 0；
 n++;
 // ...
 return n; }

6.5 传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是

传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是

当参数或者返回值类型非常大时，效率就更低

 6.6 引用和指针的区别

在 语法概念上 引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main()
{
 int a = 10;
 int& ra = a;
 
 cout<<"&a = "<<&a<<endl;
 cout<<"&ra = "<<&ra<<endl;
 return 0; }

在 底层实现上 实际是有空间的，因为 引用是按照指针方式来实现 的。

#include <time.h>
#include<iostream>
using namespace std;

int main()
{
	int a = 10;

	int& ra = a;
	ra = 20;

	int* pa = &a;
	*pa = 20;

	return 0;
}

 

引用和指针的不同点 :

1. 引用 在定义时 必须初始化 ，指针没有要求

2. 引用 在初始化时引用一个实体后，就 不能再引用其他实体 ，而指针可以在任何时候指向任何一个同类型

实体

3. 没有 NULL 引用 ，但有 NULL 指针

4. 在 sizeof 中含义不同 ： 引用 结果为 引用类型的大小 ，但 指针 始终是 地址空间所占字节个数 (32 位平台下占 4个字节 )

5. 引用自加即引用的实体增加 1 ，指针自加即指针向后偏移一个类型的大小

6. 有多级指针，但是没有多级引用

7. 访问实体方式不同， 指针需要显式解引用，引用编译器自己处理

8. 引用比指针使用起来相对更安全

7. 指针空值nullptr(C++11)

10.1 C++98中的指针空值

在良好的 C/C++ 编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的

错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

void TestPtr()
{
 int* p1 = NULL;
 int* p2 = 0;
 
 // ……
}

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

可以看到， NULL 可能被定义为字面常量 0 ，或者被定义为无类型指针 (void*) 的常量 。不论采取何种定义，在 使用空值的指针时，都不可避免的会遇到一些麻烦，比如

void f(int) {
 cout<<"f(int)"<<endl; }
void f(int*) {
 cout<<"f(int*)"<<endl; }
int main()
{
 f(0);
 f(NULL);
 f((int*)NULL);
 return 0; }

程序本意是想通过 f(NULL) 调用指针版本的 f(int*) 函数，但是由于 NULL 被定义成 0 ，因此与程序的初衷相悖。

在 C++98 中，字面常量 0 既可以是一个整形数字，也可以是无类型的指针 (void*) 常量，但是编译器默认情况下

将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转 (void *)0 。

注意：

1. 在使用 nullptr 表示指针空值时，不需要包含头文件，因为 nullptr 是 C++11 作为新关键字引入的 。

2. 在 C++11 中， sizeof(nullptr) 与 sizeof((void*)0) 所占的字节数相同。

3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用 nullptr 。