一、命名空间

1、namespace的意义

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全

局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名

冲突或名字污染，namespac关键字的出现就是针对这种问题的。

c语言项目类似下面程序这样的命名冲突是普遍存在的问题，C++引入namespac就是为了更好的解决

这样的问题：（因为我们设置的变量rand和stdlib.h中的rand函数冲突所以报错）

<code>#include <stdio.h>

#include <stdlib.h>

int rand = 10;

int main()

{

// 编译报错：error C2365: “rand”: 重定义；以前的定义是“函数”

printf("%d\n", rand);

return 0;

}

2、namespace的定义

1、定义命名空间，需要使用法到namespace关键字，后面跟命名空间的名字，然后接⼀对{}即可，{}中

即为命名空间的成员。命名空间中可以定义变量/函数/类型等。（注意{}后不跟“；”）。

2、namespace本质是定义出⼀个域，这个域跟全局域各自独立，不同的域可以定义同名变量，所以下

面的rand不在冲突了。

#include<iostream>

#include <stdio.h>

#include <stdlib.h>

namespace tmp

{

int rand = 0;

}

int main()

{

printf("%d\n", rand);

return 0;

}

3、C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/

类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响

编译查找逻辑，还会影响变量的声明周期，命名空间域和类域不影响变量声明周期。

4、namespace只能定义在全局，当然他还可以嵌套定义。

#include<iostream>

#include <stdio.h>

#include <stdlib.h>

namespace tmp

{

int rand = 0;

namespace tmp1

{

int Add(int left, int right)

{

return left + right;

}

struct Node

{

struct Node* next;

int val;

};

}

}

int main()

{

printf("%d\n", rand);

return 0;

}

5、项目工程中多文件中定义的同名namespace会认为是⼀个namespace，不会冲突。

test.c文件

#include<iostream>

#include <stdio.h>

#include <stdlib.h>

#include"test.h"

namespace tmp

{

int rand = 0;

namespace tmp1

{

int Add(int left, int right)

{

return left + right;

}

struct Node

{

struct Node* next;

int val;

};

}

}

int main()

{

printf("%d\n", tmp::d);

return 0;

}

test.h文件

#pragma once

namespace tmp

{

int d = 0;

}

可以发现在.c文件中可以使用tmp空间中的d变量 。

6、C++标准库都放在⼀个叫std(standard)的命名空间中。

7、如果想使用全局域中的变量我们可以这么操作：

int a = 3;

int main()

{

int a = 0;

printf("%d\n", ::a);

return 0;

}

这样printf先打印的是3。

3、命名空间的使用

编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。所以

下面程序会编译报错。

namespace tmp

{

int d = 0;

namespace tmp1

{

int Add(int left, int right)

{

return left + right;

}

struct Node

{

struct Node* next;

int val;

};

}

}

int main()

{

int a = 0;

printf("%d\n", d);//未定义标识符d

return 0;

}

所以我们要使用命名空间中定义的变量/函数，有三种方式：

1、指定命名空间访问，项目中推荐这种方式。

tmp::d

2、using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。

namespace tmp

{

int d = 0;

namespace tmp1

{

int Add(int left, int right)

{

return left + right;

}

struct Node

{

struct Node* next;

int val;

};

}

}

using tmp::d;

int main()

{

int a = 0;

printf("%d\n", d);//未定义标识符d

return 0;

}

3、展开命名空间中全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

namespace tmp

{

int d = 0;

namespace tmp1

{

int Add(int left, int right)

{

return left + right;

}

struct Node

{

struct Node* next;

int val;

};

}

}

using namespace tmp;

int main()

{

int a = 0;

printf("%d\n", d);//未定义标识符d

return 0;

}

二、输入和输出

1、 是 Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输

出对象。

2、std::cin 是 istream 类的对象，它主要面向窄字符（narrow characters (of type char)）的标准输

入流。

3、std::cout 是 ostream 类的对象，它主要面向窄字符的标准输出流。

4、std::endl 是⼀个函数，流插入输出时，相当于插入⼀个换行字符加刷新缓冲区。

5、<<是流插入运算符，>>是流提取运算符。（C语言还用这两个运算符做位运算左移/右移）

6、使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动指定格式，C**++的输入**

输出可以自动识别变量类型(本质是通过函数重载实现的)，其实最重要的是C++的流能更好的支持自定义

类型对象输入和输出。

#include<iostream>

#include <stdio.h>

#include <stdlib.h>

namespace tmp

{

int a = 0;

double b = 0.0;

char c = '0';

namespace tmp1

{

int Add(int left, int right)

{

return left + right;

}

struct Node

{

struct Node* next;

int val;

};

}

}

using namespace tmp;

using namespace std;

int main()

{

cin >> a >> b >> c;

cout << a << b << c;

return 0;

}

7、cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要

通过命名空间的使用方式去用他们。

8、⼀般日常练习中我们可以using namespace std，实际项目开发中不建议using namespace std。

三、 缺省参数

1、缺省参数的定义以及规定

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

则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方把

缺省参数也叫默认参数）。

全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左

依次连续缺省，不能间隔跳跃给缺省值。

带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。

函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省

值。

#include <iostream>

using namespace std;

void Func(int a = 0)

{

cout << a << endl;

}

int main()

{

Func(); // 没有传参时，使⽤参数的默认值

Func(10); // 传参时，使⽤指定的实参

return 0;

}

2、全缺省和半缺省

<code>#include <iostream>

using namespace std;

// 全缺省

void Func1(int a = 10, int b = 20, int c = 30)

{

cout << "a = " << a << endl;

cout << "b = " << b << endl;

cout << "c = " << c << endl << endl;

}

// 半缺省

void Func2(int a, int b = 10, int c = 20)

{

cout << "a = " << a << endl;

cout << "b = " << b << endl;

cout << "c = " << c << endl << endl;

}

int main()

{

Func1();

Func1(1);

Func1(1, 2);

Func1(1, 2, 3);

Func2(100);

Func2(100, 200);

Func2(100, 200, 300);

return 0;

}

半缺省不能这么写：

void Func2(int a = 10, int b, int c = 20)

{

cout << "a = " << a << endl;

cout << "b = " << b << endl;

cout << "c = " << c << endl << endl;

}

//或者

void Func2(int a = 10, int b, int c)

{

cout << "a = " << a << endl;

cout << "b = " << b << endl;

cout << "c = " << c << endl << endl;

}

必须严格遵守：

半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。

3、缺省参数的实际应用

我们在没有学c++之前我们实现栈的初始化以及插人时我们是这么写的：

typedef int STDataType;

typedef struct Stack

{

STDataType* a;

int top;

int capacity;

}ST;

// 栈顶

void STInit(ST* ps, int n)

{

assert(ps);

ps->a = (STDataType*)malloc(n * sizeof(STDataType));

ps->top = 0;

ps->capacity = n;

}

void STPush(ST* ps, STDataType x)

{

assert(ps);

// 满了， 扩容

if (ps->top == ps->capacity)

{

printf("扩容\n");

int newcapacity = ps->capacity == 0 ? 4 : ps->capacity

* 2;

STDataType* tmp = (STDataType*)realloc(ps->a,

newcapacity * sizeof(STDataType));

if (tmp == NULL)

{

perror("realloc fail");

return;

}

ps->a = tmp;

ps->capacity = newcapacity;

}

ps->a[ps->top] = x;

ps->top++;

}

如果我们要插入100个数据则就需要不断的扩容，有效率的损耗，但是我们在学习了缺省参数后我们可以这么写：

// 栈顶

void STInit(ST* ps, int n = 4)

{

assert(ps);

ps->a = (STDataType*)malloc(n * sizeof(STDataType));

ps->top = 0;

ps->capacity = n;

}

void STPush(ST* ps, STDataType x)

{

assert(ps);

// 满了， 扩容

if (ps->top == ps->capacity)

{

printf("扩容\n");

int newcapacity = ps->capacity == 0 ? 4 : ps->capacity

* 2;

STDataType* tmp = (STDataType*)realloc(ps->a,

newcapacity * sizeof(STDataType));

if (tmp == NULL)

{

perror("realloc fail");

return;

}

ps->a = tmp;

ps->capacity = newcapacity;

}

ps->a[ps->top] = x;

ps->top++;

}

int main()

{

ST a;

STInit(&a, 100);//这里不传100也可以，因为规定必须从左到右依次给实参，不能跳跃给实参。刚好和缺省参数确定位置互补

for (int i = 0; i < 100; i++)

{

STPush(&a, i);

}

return 0;

}

这样就有效避免了重复开辟空间的问题。

四、函数重载

C++支持持在同⼀作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者

类型不同。这样C++函数调用就表现出了多态行为，使用更灵活。（但是返回值不同不能作为重载条件，

因为调用时也无法区分，如果返回值和参数类型或者个数同时变化则也为重载条件）。

1、参数类型不同

#include<iostream>

using namespace std;

// 1、参数类型不同

int Add(int left, int right)

{

cout << "int Add(int left, int right)" << endl;

return left + right;

}

double Add(double left, double right)

{

cout << "double Add(double left, double right)" << endl;

return left + right;

}

2、参数个数不同

// 2、参数个数不同

void f()

{

cout << "f()" << endl;

}

void f(int a)

{

cout << "f(int a)" << endl;

}

特别的如果上面的用缺省参数那么在不传参数调用时就会报错，编译器不知道调用谁

// 下⾯两个函数构成重载

// f()但是调⽤时，会报错，存在歧义，编译器不知道调⽤谁

void f1()

{

cout << "f()" << endl;

}

void f1(int a = 10)

{

cout << "f(int a)" << endl;

}

3、参数顺序不同（实际上就是参数类型不同）

// 3、参数类型顺序不同

void f(int a, char b)

{

cout << "f(int a,char b)" << endl;

}

void f(char b, int a)

{

cout << "f(char b, int a)" << endl;

}

#include<iostream>

using namespace std;

// 1、参数类型不同

int Add(int left, int right)

{

cout << "int Add(int left, int right)" << endl;

return left + right;

}

double Add(double left, double right)

{

cout << "double Add(double left, double right)" << endl;

return left + right;

}

// 2、参数个数不同

void f()

{

cout << "f()" << endl;

}

void f(int a)

{

cout << "f(int a)" << endl;

}

void f(int a, char b)

{

cout << "f(int a,char b)" << endl;

}

void f(char b, int a)

{

cout << "f(char b, int a)" << endl;

}

int main()

{

Add(10, 20);

Add(10.1, 20.2);

f();

f(10);

f(10, 'a');

f('a', 10);

return 0;

}

`#include<iostream>

using namespace std;

// 1、参数类型不同

int Add(int left, int right)

{

cout << "int Add(int left, int right)" << endl;

return left + right;

}

double Add(double left, double right)

{

cout << "double Add(double left, double right)" << endl;

return left + right;

}

// 2、参数个数不同

void f()

{

cout << "f()" << endl;

}

void f(int a)

{

cout << "f(int a)" << endl;

}

void f(int a, char b)

{

cout << "f(int a,char b)" << endl;

}

void f(char b, int a)

{

cout << "f(char b, int a)" << endl;

}

int main()

{

Add(10, 20);

Add(10.1, 20.2);

f();

f(10);

f(10, 'a');

f('a', 10);

return 0;

}``

结果：