C++常见概念

第一个 C++ 程序

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

命名空间

#include<stdio.h>int rand = 10;int main()
{printf("%d", rand);return 0;
}

#include<stdio.h>
#include<stdlib.h>int rand = 10;
//编译报错：error C2365: 
//“rand”: 重定义；以前的定义是“函数”int main()
{printf("%d", rand);return 0;
}

在 C 语言中，有大量的变量和函数存在于全局作用域中，可能会导致很多的命名冲突。因此，C++ 中引入命名空间的目的是对这些标识符的名称进行本地化，以避免命名冲突和名字污染。

namespace

定义命名空间，需要使用`namespace`关键字。命名空间中可以定义变量、函数、类型等。

namespace namespace_name
{//成员
}

namespace的本质是定义一个命名空间域，这个域跟全局域各自独立，不同的域可以定义同名变量。

C++ 中，域包括函数局部域，全局域，命名空间域，类域。其中，局部域和全局域不仅会影响编译查找逻辑，还会影响变量的生命周期；而命名空间域和类域不影响变量生命周期。

域影响的是编译时语法查找一个变量/函数类型出处的逻辑，所以有了域的隔离，命名冲突得以解决。

编译查找的逻辑：

1. 先局部，后整体
2. 指定域查找

• namespace只能定义在全局中。
• namespace支持嵌套定义。
• 项目工程中多文件中定义的同名namespace会认为是同一个namespace，不会冲突。

命名空间的使用

编译时查找一个变量的定义/声明时，默认只会在局部域或全局域中寻找。我们要使用命名空间中定义的变量/函数，有一下三种方式：

• 指定命名空间访问

使用域作用限定符::

#include<iostream>using namespace std;int a = 10;namespace space
{int a = 0;int b = 1;
}int main()
{int a = 20;cout << ::a << endl;//全局域，输出 20cout << a << endl;//局部域，输出 10cout << space::a << endl;//命名空间域，输出 0return 0;
}

• 展开命名空间中的全部成员

使用using namespace指令展开命名空间，这样在使用命名空间时就可以不用在前面加上命名空间的名称。

using namespace namespace_name;

#include<iostream>using namespace std;namespace space
{int a = 0;int b = 1;
}using namespace space;int main()
{cout << a << endl;return 0;
}

• 展开命名空间中的某个成员

使用using指令展开命名空间中的某个成员。

using namespace_member_name;

#include<iostream>using namespace std;namespace space
{int a = 0;int b = 1;
}using space::a;int main()
{cout << a << endl;cout << space::b << endl;return 0;
}

注意：使用using展开时，在存在同名变量的情况下，若存在局部域变量，则局部域变量的优先级最高；若仅存在全局域变量与命名空间变量，会报错。

#include<iostream>using namespace std;int a = 10;namespace space
{int a = 0;int b = 1;
}using namespace space;int main()
{int a = 20;cout << a << endl;//输出 20return 0;
}

#include<iostream>using namespace std;int a = 10;namespace space
{int a = 0;int b = 1;
}using namespace space;int main()
{cout << a << endl;//编译报错：error C2872//“a”: 不明确的符号return 0;
}

输入与输出

iostream.h是 Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。

在 C++ 中，标准库都放在名为std的命名空间中。

• std::cin是iostream类的对象，它主要面向窄对象（char类型的变量）的标准输入流。
• std::cout是iostream类的对象，它主要面向窄字符的标准输出流。
• std::endl是一个函数，在流插入输出时，相当于插入一个换行符并刷新缓冲区。
• <<是流插入运算符，>>是流提取运算符号。

C++ 的输入输出方式相较于scanf和printf，C++ 的输入输出可以自动识别变量类型（本质通过函数重载实现），并且能够更好的支持自定义类型对象的输入和输出。

#include<iostream>using namespace std;int main()
{int a = 0;double b = 0.1;char c = 'x';cin >> a >> b >> c;cout << a << " " << b << " " << c << endl;return 0;
}

注意：

在VS2022编译器中，iostream编译器中间接包含了scanf和printf函数，因此没有包含stdio.h也可以使用scanf和printf函数，但其他编译器可能会报错。

#include<iostream>
using namespace std;
int main()
{// 在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码// 可以提⾼C++IO效率ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
}

缺省参数

缺省参数是声明或定义函数时**为函数的参数指定一个缺省值**。在调用该函数时，如果**没有指定实参，则采用该形参的缺省值，否则使用指定的实参**。缺省参数分为全缺省和半缺省参数。（有些地方把缺省参数也叫默认参数）

• 全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++ 规定，半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
• 带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。
• 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须在函数声明中给缺省值。

#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;
}void Func2(int a, int b = 20, int c = 30)
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl;
}int main()
{Func1();Func1(1);Func1(1, 2);Func1(1, 2, 3);//不支持Func1(,,3)Func2(1);Func2(1, 2);Func2(1, 2, 3);
}

例如在栈的实现中，我们便可以通过使用缺省参数来简化栈的初始化。

Stack.h

Stack.c

#include<iostream>
#include<assert.h>typedef int STDataType;typedef struct Stack
{STDataType* arr;int top;int capacity;
}ST;void STInit(ST* ps, int n = 4);

#include"Stack.h"void STInit(ST* ps, int n)
{assert(ps);STDataType* tmp = (STDataType*)malloc(n * sizeof(STDataType));if (tmp == NULL){perror("malloc");exit(1);}ps->arr = tmp;ps->top = 0;ps->capacity = n;
}

通过缺省参数，在我们已知所需要的内存时，就不需要反复扩容，能够提升代码运行效率；在不能预知所需要的参数时，则不传入n的值，开辟4 * sizeof(STDataType)个字节的空间。

函数重载

C 语言是支持同一作用域中出现同名函数的。

C++ 支持在同一作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同、类型不同或者参数类型顺序不同。这样 C++ 函数调用就表现出了多态行为，使用更灵活。

// 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;
}// 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;
}

易错：

// 返回值不同不能作为重载条件，因为调⽤时也⽆法区分
//void fxx()
//{}
//
//int fxx()
//{
//	return 0;
//}//下⾯两个函数构成重载
//但是调⽤时，会报错
//在不输入参数的情况下，存在歧义，编译器不知道调⽤谁
void f1()
{cout << "f()" << endl;
}
void f1(int a = 10)
{cout << "f(int a)" << endl;
}

引用

概念与定义

引用是给**已存在的变量**取一个别名，编译器不会为引用变量开辟内存空间， 它和它引用的变量共用同一块内存空间。

类型 & 引用别名=引用对象;

#include<iostream>using namespace std;int main()
{int a = 0;int& b = a;int& c = b;//c也相当于是a的引用c++;//a，b，c的值相同cout << a << " " << b << " " << c << endl;//a，b，c的地址相同cout << &a << endl;cout << &b << endl;cout << &c << endl;return 0;
}

引用的特性

• 引用在定义时必须初始化
• 一个变量可以有多个引用
• 引用不能改变指向，一旦引用一个实体，就不能再引用其他实体

#include<iostream>using namespace std;int main()
{int a = 10;int& b = a;//int& b;//编译报错：“b” :必须初始化引⽤int c = 20;b = c;//此处并非让b引用c，因为C++中引用不能改变指向//此处是一个赋值cout << a << " " << b << endl;//输出 20 20//a和b的地址与c不同cout << &a << endl;cout << &b << endl;cout << &c << endl;return 0;
}

引用的使用

引用在实践中主要用于引用传参和引用做返回值，使得减少拷贝提高效率和改变引用对象的同时改变被引用对象。

• 引用传参和指针传参的功能是类似的，且引用传参相对更加方便。
• 在部分 C 语言实现的数据结构中，可以使用 C++ 引用代替指针传参，在需要使用二级指针等复杂的指针时，可以简化程序。

#include<iostream>using namespace std;void swap(int* a, int* b)
{int tmp = *a;*a = *b;*b = tmp;
}void swap(int& a, int& b)
{int tmp = a;a = b;b = tmp;
}int main()
{int a = 1;int b = 2;swap(&a, &b);cout << a << " " << b << endl;swap(a, b);cout << a << " " << b << endl;return 0;
}

• 引用作返回值，能够对返回对象进行修改。

#include<iostream>
#include<assert.h>using namespace std;//使用引用来实现栈
typedef int STDataType;
typedef struct Stack
{STDataType* arr;int top;int capacity;
}ST;void STInit(ST& rs, int n = 4)
{rs.arr = (STDataType*)malloc(n * sizeof(STDataType));rs.top = 0;rs.capacity = n;
}void STPush(ST& rs, STDataType x)
{assert(rs.arr);if (rs.top == rs.capacity){int newcapacity = rs.capacity == 0 ? 4 : 2 * rs.capacity;STDataType* tmp = (STDataType*)realloc(rs.arr, newcapacity * sizeof(STDataType));if (tmp == NULL){perror("malloc");exit(1);}rs.arr = tmp;rs.capacity = newcapacity;}rs.arr[rs.top++] = x;
}//...int& STTop(ST& rs)//返回的是别名，是一个左值，能够修改返回对象
{assert(rs.arr);return rs.arr[rs.top - 1];
}
/*
int STTop(ST& rs)
编译报错：“+=” :左操作数必须为左值
返回值为拷贝的临时变量，是一个右值，具有常性
*/int main()
{ST st1;STInit(st1);STPush(st1, 1);STPush(st1, 2);STPush(st1, 3);cout << STTop(st1) << endl;STTop(st1) += 10;cout << STTop(st1) << endl;return 0;
}

int& func(int x, int y)
{return x + y;
}
//结果将产生野引用

注意：不是所有的函数都可以将引用作为返回值。

STTop函数结束，栈帧销毁，但STTop的返回对象不在栈帧中，可以将引用作为返回值。

Func函数结束，栈帧销毁，但Func的返回对象在帧帧中，不可以将引用作为返回值。

const引用

> + 引用一个`const`对象必须用`const`引用，但是`const`引用可以引用普通对象。这是因为**对象的访问权限可以缩小，但不能变大**。 > + 临时对象就是编译器需要一个空间暂存值时临时创建的一个未命名的对象， C++ 中把这个未命名对象叫做临时对象。 临时对象包括**函数传值返回**，**表达式运算**和**类型转换**。C++ 中规定，临时对象具有常性，因此使用普通引用将会触发权限放大，必须要使用常引用。 >

#include<iostream>using namespace std;int main()
{const int a = 10;const int& ra = a;//int& ra = a;//编译报错：error C2440 : “初始化” :⽆法从“const int”转换为“int& ”//这⾥的引⽤是对a访问权限的放⼤//ra++;//编译报错：error C3892 : “ra”:不能给常量赋值int b = 20;const int& rb = b;//这里的引用是对b访问权限的缩小//但是并不会印象b的访问权限//rb++;//编译报错：error C3892 : “rb”:不能给常量赋值int c = 10;const int& rc = 3 * c;//int& rc = 3 * c;//编译报错: “初始化” :⽆法从“int”转换为“int& ”double d = 12.34;const int& rd = d;//int& rd = 3 * d;//编译报错: “初始化” :⽆法从“double”转换为“int& ”return 0;
}

指针和引用

C++ 中指针和引用的功能有重叠性，但是各有自己的特点，互相不可替代。

• 语法概念上引用是一个变量的取别名，不开辟新的空间，而指针是存储一个变量地址，需要开辟新的空间。
• 引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
• 引用在初始化时引用一个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。
• 引用可以直接访问指向对象，指针需要解引用才是访问指向对象。
• sizeof中，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数。
• 指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全⼀些。

inline

用`inline`修饰的函数叫做内联函数，编译时 C++ 编译器会在调用的地方展开内联函数，这样调用内联函数就不需要建立栈帧，可以提高效率。

• inline对于编译器而言只是一个建议，也就是说，加了inline，编译器也可以选择在调用的地方不展 开。不同编译器关于inline什么情况展开的情况各不相同，因为 C++ 标准没有规定。一般而言，inline适用于频繁调用的短小函数。对于递归函数或代码多些的函数，加上inline，也会被编译器忽略。
• C语言 实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不方便调试，C++ 设计了inline目的就是替代 C 语言 的宏函数。 在 C++ 中，通常会使用inline代替的 C 语言中的宏函数，使用const和enum替代 C 语言中的宏常量。
• vs2022的debug版本下默认是不展开inline的，这样方便调试，debug版本想展开，需要设置一下 以下两个地方。

inline存在的问题是一定程度会让编译后的可执行程序变大。

#include<iostream>using namespace std;inline int ADD(int x, int y)
{int ret = x + y;return ret;
}int main()
{//可以通过汇编观察程序是否展开//有call ADD语句则说明没有展开//函数编译好后变为一串指令//函数的地址就是第一行指令的地址//call的本质就是跳跃过去执行指令int ret = ADD(2, 3);cout << ret << endl;return 0;
}

#include<iostream>using namespace std;int ADD(int x, int y)
{int ret = x + y;return ret;
}int main()
{int ret = ADD(2, 3);cout << ret << endl;return 0;
}

inline不建议声明和定义分离到两个文件，分离会导致链接错误。因为inline被展开不是调用，因此内联函数不会进入符号表，就找不到内联函数的函数地址，链接时会出现报错。因次，内联函数一般直接定义在.h文件中。

`nullptr`

`NULL`实际是一个宏，在`stddef.h`中，可以看到以下代码：

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

#include<iostream>
using namespace std;void f(int x)
{cout << "f(int x)" << endl;
}
void f(int* ptr)
{cout << "f(int* ptr)" << endl;
}
int main()
{f(0);f(NULL);//本想通过f(NULL)调⽤指针版本的f(int*)函数//但是由于NULL被定义成0，调⽤了f(intx)，因此与程序的初衷相悖。f((int*)NULL);//需要强制类型转换才能调用函数// f((void*)NULL);// 编译报错：error C2665 : “f”: 2个重载中没有⼀个可以转换所有参数类型f(nullptr);return 0;
}

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

C++11 中引入nullptr，nullptr是⼀个特殊的关键字，nullptr是⼀种特殊类型的字面量，它可以转换 成任意其他类型的指针类型。使用nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式地转换为指针类型，而不能被转换为整数类型。