C++基础入门知识整理与总结_c++基础知识

一.C++基础

C++概念：C++是美国贝尔实验室的Bjarne Stroustrup博士在C语言的基础上，弥补了C语言存在的一些缺陷，增加了面向对象的特征，于1980年开发出来的一种面向过程性与面向对象性相结合的程序设计语言。最初他把这种新的语言称为“含类的C”，到1983年才取名为C++。
相比C语言，C++的主要特点是增加了面向对象机制。

C++关键字

C++共计63个关键字，汇总如下：

命名空间

在C++中，变量，函数，类的使用都是大量存在的，且都存在于全局作用域中，可能会导致冲突。因此使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这个问题。

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

// 普通命名空间
1

// An highlighted block
namespace N1 // N1为命名空间的名称
{
 // 命名空间中的内容，既可以定义变量，也可以定义函数
     int a;
     int Add(int left, int right)
     {
        return left + right;
     }
}
1
2
3
4
5
6
7
8
9
10

//  命名空间可以嵌套
1

// An highlighted block
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;
   }
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中
1

// An highlighted block
namespace N1
{
     int Mul(int left, int right)
     {
         return left * right;
     }
}
1
2
3
4
5
6
7
8

命名空间的使用有三种方式：

//加命名空间名称及作用域限定符
1

// An highlighted block
int main()
{
     printf("%d\n", N::a);
     return 0; 
}
1
2
3
4
5
6

// 使用using将命名空间中成员引入
1

// An highlighted block
using N::b;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    return 0; 
}
1
2
3
4
5
6
7
8

//使用using namespace 命名空间名称引入
1

// An highlighted block
using namespce N;
int main()
{
     printf("%d\n", N::a);
     printf("%d\n", b);
     Add(10, 20);
     return 0; 
}
1
2
3
4
5
6
7
8
9

C++输入和输出

// C++的实现——基本的输出输入格式
1

// An highlighted block
#include<iostream>
using namespace std;
int main()
{
      cout<<"Hello world!!!"<<endl;
      return 0;
}
1
2
3
4
5
6
7
8

使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空
间。
注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件
即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文
件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用
+std的方式。

cin:(标准输入流)负责从键盘读取数据，使用提取操作符 ">>"就可以将从键盘输入的数据读入到变量中，语法格式为：
cin>>变量1>>变量2>>…>>变量n；

//  使用C++输入输出更方便，不需增加数据格式控制，比如：整形--%d，字符--%c
1

// An highlighted block
#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

缺省参数

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

// 缺省参数代码示例：
1

// An highlighted block
void TestFunc(int a = 0)
{
 cout<<a<<endl;
}
int main()
{
 TestFunc(); // 没有传参时，使用参数的默认值
 TestFunc(10); // 传参时，使用指定的实参
}
1
2
3
4
5
6
7
8
9
10

分类：
全缺省参数
半缺省参数

注意：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现
3. 缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持）

函数重载

在C++中，用户可以重载函数。这意味着，在同一作用域内，只要函数参数的类型不同，或者参数的个数不同，或者二者兼而有之，两个或者两个以上的函数可以使用相同的函数名。

函数重载的概念

函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题。

//函数重载代码示例：
1

// An highlighted block
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

extern “C”

有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译。比如：tcmalloc是google用C++实现的一个项目，他提供tcmallc()和tcfree两个接口来使用，但如果是C项目就没办法使用，那么他就使用extern “C”来解决。

// 代码示例：
1

// An highlighted block
extern "C" int Add(int left, int right);
int main()
{
     Add(1,2);
     return 0;
}
1
2
3
4
5
6
7

引用

引用的概念

引用（reference）是C++对C的一个重要扩充。变量的引用就是变量的别名，因此引用又称别名。
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间

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

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

// An highlighted block
void TestRef()
{
 int a = 10;
 int& ra = a; //<====定义引用类型
 
 printf("%p\n", &a);
 printf("%p\n", &ra);
}
1
2
3
4
5
6
7
8
9

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

引用特性

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

// An highlighted block
//正确示例
int a = 10;
int& b = a;//引用在定义时必须初始化
//错误示例
int a = 10;
int &b;//定义时未初始化
b = a;
1
2
3
4
5
6
7
8

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

// An highlighted block
int a = 10;
int& b = a;
int& c = a;
int& d = a;
1
2
3
4
5

//4. 引用一旦引用一个实体，再不能引用其他实体;
1

// An highlighted block
	int a = 10;
	int& b = a;
	int c = 20;
	b = c;//你的想法：让b转而引用c
1
2
3
4
5

// A code block
var foo = 'bar';
1
2

// An highlighted block
void TestRef()
{
 int a = 10;
 // int& ra; // 该条语句编译时会出错
 int& ra = a;
 int& rra = a;
 printf("%p %p %p\n", &a, &ra, &rra); 
}
1
2
3
4
5
6
7
8
9

常引用

上面提到，引用类型必须和引用实体是同种类型的。但是仅仅是同种类型，还不能保证能够引用成功，这儿我们还要注意可否可以修改的问题。

//这里的a，b，d都是常量，常量是不可以被修改的，但是如果你用int&ra等这样
来引用a的话，那么引用的这个a是可以被修改的，因此会出问题;
1
2

// An highlighted block
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;
}
1
2
3
4
5
6
7
8
9
10
11
12

针对于上述问题请看下面代码：

// 对面这段代码是跑不通的，因为int到double存在隐士类型的提升，而在提升
的过程中系统会创建一个常量区来存放a类型提升后的结果;
1
2

// An highlighted block
#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	double&ra = a;
}
1
2
3
4
5
6
7
8

针对于上述问题 ，在 double&ra = a; 前面加上const即可

注意：将不可修改的量用可读可写的量来引用是不可以的，但是反过来是可以的，将可读可写的量用只可读的量来引用是可以的。

使用场景

1.引用做参数

// 学习C语言的时候经常用交换函数来说明传值和传址的区别。现在学习了引用，
就可以不用指针作为形参了。因为在这里a和b是传入实参的引用，我们将a和b的
值交换，就相当于将传入的两个实参交换了;
1
2
3

// An highlighted block
//交换函数
void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
1
2
3
4
5
6
7
8

2.引用做返回值

引用也能做返回值，但是要特别注意，我们返回的数据不能是函数内部创建的普通局部变量，因为在函数内部定义的普通的局部变量会随着函数调用的结束而被销毁。我们返回的数据必须是被static修饰或者是动态开辟的或者是全局变量等不会随着函数调用的结束而被销毁的数据。

// 不加staic的时候，最后生成的结果为7;
1

// An highlighted block
#include<iostream>
using namespace std;
int& Add(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	int& ans = Add(1, 2);
	Add(3, 4);
	cout << ans << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

此图为上述代码运行结果：

如果将上述代码Add(3,4)换成printf（“hehe\n”）则会生成一堆随机数；

原因：

因为你在函数里定义的变量是临时变量，出了函数函数是会销毁的，这时它就随机指向内存中的一块空间了。所以在引用做函数返回值时最好还是给在函数中定义的变量加上static。

加上static之后的代码及结果：

为什么答案是3的原因：
因为第5行代码前加了static，到这里就不会执行这段定义C的代码，再执行一次相当于被重新定义，因此直接return c；

注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

传值、传引用效率比较

引用和指针的区别

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

// A code block
var foo = 'bar';
1
2

// An highlighted block
int main()
{
 int a = 10;
 int& ra = a;
 
 cout<<"&a = "<<&a<<endl;
 cout<<"&ra = "<<&ra<<endl;
 return 0; 
 }
1
2
3
4
5
6
7
8
9
10

上述代码运行结果如下：

引用和指针的不同点:

1. 引用在定义时必须初始化，指针没有要求
2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
3. 没有NULL引用，但有NULL指针
4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
6. 有多级指针，但是没有多级引用
7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
8. 引用比指针使用起来相对更安全

内联函数

在函数名前冠以关键字inline，该函数就被声明为内联函数。每当程序中出现对该函数的调用时，C++编译器使用函数体中的代码插入到调用该函数的语句之处，同时使用实参代替形参，以便在程序运行时不再进行函数调用。
引入内联函数主要是为了消除调用函数时的系统开销，以提高运行速度。

// 内敛函数定义形式;
1

// An highlighted block
inline 函数类型 函数名（形式参数表）
{
	函数体
}
1
2
3
4
5

形式上只需要在函数类型前加一个关键字inline即可。内联函数是函数的一种特殊形式。

// 使用内联函数求3个整数中的最大值;
1

// An highlighted block
#include<iostream>
using namespace std;
inline int max(int x, int y, int z)
{
	return((x >= y) ? (x >= z ? x : z) : (y >= z ? y : z));
}
void main()
{
	int a, b, c;
	cout << "enter three integers;";
	cin >> a >> b >> c;//cin是标准输入流，使用提取操作符>>
	cout << "Maximum is " << max(a, b, c) << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

内联函数之所以能够减少函数调用时的系统空间和时间开销，是因为系统在编译程序时就已 经把内联函数的函数体代码插人到相应的函数调用位置，成为主调函数内的一-段代码， 可以直接执行，不必再转换流程控制权。这样的结构自然节省了时间和空间开销，但使得主调函数代码变长。一般是只把短小的函数写成内联函数。而且还要注意以下两方面问题。

内联函数体不能包含循环语句、switch 语句。

内联函数要 先定义、后调用，不能先声明内联函数原型，再调用、定义。

内联函数的特性

1.inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长/递归的函数不适宜
使用作为内联函数。

2.inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内代码比较长/递归等，编译器优化时会忽略掉内联。

3.inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会
找不到。

auto关键字

一个变量在内存中存在的时间取决于变量的存储类型，C++程序中使用的变量可分为4种存储类型：
auto、register、extern、static。这里先只介绍auto关键字

auto简介

在早期的C/C++中auto的含义是：使用auto修饰的变量是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它。

在C++11中，标准委员会赋予了auto全新的含义：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

// auto关键字说明举例;
1

// An highlighted block
int TestAuto()
{
  return 10;
}
int main()
{
 int a = 10;
 auto b = a;
 auto c = 'a';
 auto d = TestAuto();
 
 cout << typeid(b).name() << endl;
 cout << typeid(c).name() << endl;
 cout << typeid(d).name() << endl;
 
 //auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
 return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

注意事项：
使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

使用细则

1. auto与指针和引用结合起来使用用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

// 用auto声明引用时必须加&，否则创建的只是与实体类型相同的普通变量，
只不过将其换了个姓名而已 ;
1
2

// An highlighted block
#include <iostream>
using namespace std;
int main()
{
	int a = 10;
	auto b = &a;   //自动推导出b的类型为int*
	auto* c = &a;  //自动推导出c的类型为int*
	auto& d = a;   //自动推导出d的类型为int
	//打印变量b,c,d的类型
	cout << typeid(b).name() << endl;//打印结果为int*
	cout << typeid(c).name() << endl;//打印结果为int*
	cout << typeid(d).name() << endl;//打印结果为int
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. 在同一行定义多个变量
   当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

// 不能在同一行定义不同变量，以下代码举例说明;
1

// An highlighted block
void TestAuto()
{
 auto a = 1, b = 2; 
 auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}
1
2
3
4
5
6

auto不能推导的场景

// 1.auto做为函数的参数;
1

// An highlighted block
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

1
2
3
4
5

//2.auto不能直接用来声明数组;
1

// An highlighted block
void TestAuto()
{
 int a[] = {1,2,3};
 auto b[] = {4，5，6};
}
1
2
3
4
5
6

3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
4. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等
   进行配合使用。

基于范围的for循环

范围for的语法

在C++98中如果要遍历一个数组，可以按照以下方式进行：

// A code block
var foo = 'bar';
1
2

// An highlighted block
void TestFor()
{
 int array[] = { 1, 2, 3, 4, 5 };
 for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
 array[i] *= 2;
 
 for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)
 cout << *p << endl;
}
1
2
3
4
5
6
7
8
9
10

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

// A code block
var foo = 'bar';
1
2

// An highlighted block
void TestFor()
{
 int array[] = { 1, 2, 3, 4, 5 };
 for(auto& e : array)
 e *= 2;
 
 for(auto e : array)
 cout << e << " ";
 
 return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

范围for的使用条件

1.for循环迭代的范围必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

// 注意：以下代码就有问题，因为for的范围不确定;
1

// An highlighted block
void TestFor(int array[])
{
 for(auto& e : array)
 cout<< e <<endl;
}
1
2
3
4
5
6

2. 迭代的对象要实现++和==的操作。

指针空值—nullptr

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。