c++基础知识

最新推荐文章于 2024-09-02 23:09:18 发布

吹个泡泡（c++后端开发）

最新推荐文章于 2024-09-02 23:09:18 发布

阅读量754

点赞数 17

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/2301_77987288/article/details/139225826

版权

命名空间

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

命名空间的定义
定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}
中即为命名空间的成员。
命名空间中可以定义变量/函数/类型
1.正常的命令空间定义

namespace ns1 {
	int a;
	int b;
	struct ListNode {
		int _val;
		struct ListNode* _next;
	};
}

2.命名空间也可以嵌套

namespace N1 {
	int a;
	int b;
	namespace N2 {
		int c;
		int d;
	}
}

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

namespace N1 {
	int a;
	int b;
	namespace N2 {
		int c;
		int d;
	}
}
namespace N1 {
	int e;
	int Sum(int left, int right) {
		return left + right;
	}
}

那么命名空间怎么使用呢？
命名空间的使用有三种方式：

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

int main()
{
	cout << N1::a << endl;
	return 0;
}

使用using将命名空间中某个成员引入

using N1::b;
int main()
{
	cout << b << endl;
	return 0;
}

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

using namespace N1;
int main()
{
	cout << a <<  endl;
	cout << b << endl;
	return 0;
}

td命名空间的使用惯例：
std是C++标准库的命名空间，如何展开std使用更合理呢？

在日常练习中，建议直接using namespace std即可，这样就很方便。
using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对
象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模
大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间 +
using std::cout展开常用的库对象/类型等方式。

c++输入与输出

c++兼用c语言的用法，c语言的printf 和scanf仍然可以用。
c++风格：

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
cout<<"Hello world!!!"<<endl;
return 0;
}

使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件
以及按命名空间使用方法使用std
cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含<
iostream >头文件中。
<<是流插入运算符，>>是流提取运算符。
使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。
C++的输入输出可以自动识别变量类型。

缺省参数

概念：缺省参数是指定义函数时，给函数的参数缺省值，调用函数的时候如果没有传入实参，则给形参赋予缺省值，否则传入实参。

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

分类：

全缺省参数：参数都有缺省值

int Sum(int left = 0, int right = 0) {
		return left + right;
	}
	int main()
	{
		Sum();
		Sum(1,2);
		Sum(1); //此时1传给left，只能从左到右传参，不能直接传right
	}

半缺省参数：部分参数有缺省值

//此时最少传入一个参数
int Sum(int left , int right = 0) {
		return left + right;
	}
	int main()
	{
		Sum(1,2);
		Sum(1); 
	}

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

int Sum(int left = 0 , int right) {
		return left + right;
	}
	//若这样从左向右给，传入单个参数时候，是传给left还是right呢？编译器无法识别，所以不行

缺省参数不能在函数声明和定义中同时出现，若需要声明和定义同时出现，声明时写出缺省参数即可，定义时不能写出缺省参数。

函数重载

首先我们需要了解程序的形成过程：编译和链接，编译又分为（预编译，编译，汇编）

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预编译、编译、汇编、链接。
预编译：宏定义,文件包含,条件编译,去注释等。
编译：语法分析，词法分析，语义分析，符号汇总。最终形成汇编代码
汇编：把汇编代码转成二进制目标文件
链接：合并段表，符号表的合并和符号表的重定位，最终形成可执行程序

//b.cpp
int Add(int a, int b)
{
	return a + b;
}
//a.cpp
extern int Add(int a, int b)
int main()
{
	cout << Add(1,2) << endl;
}

实际项目通常是由多个头文件和多个源文件构成，，我们可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？
所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就
会到b.o的符号表中找Add的地址，然后链接到一起。
那么链接时，面对Add函数，链接接器会使用哪个名字去找呢？这里每个编译器都有自己的
函数名修饰规则。
由于Windows下vs的修饰规则过于复杂，而Linux下修饰规则简单易懂，下面我们使
用了gcc和g++演示了这个修饰后的名字。
C语言：gcc

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

c++： g++
在这里插入图片描述
在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参
数类型信息添加到修改后的名字中。
而且linux下g++函数名字修饰规则：
_Z [函数名字符个数] 函数名参数简写
如：上图的_Z3Addll 其中_Z是开头，3是函数名ADD字符个数即3，ll代表参数为两个，分别是long 和 long。
因此：c++能函数重载而c语言不支持.

引用

概念：引用就是给已经存在的变量取别名，不会重新开辟空间，它和变量共同用一块空间。
类型& 引用变量名 = 引用实体；

在这里插入图片描述
引用特点：

引用必须初始化
一个变量可以有多个引用
一但引用一个实体，就不能引用其他实体。当引用其他实体时，其实是给当前引用的实体赋值

int main(){
	int a = 10;
	int b  = 20;
	int& c = a;
	int& d = a;
	c = b; //其实是把20赋值给a
}

引用权限说明
引用权限只能缩小，不能放大权限

int main(){
	const int a = 10;
	int b  = 20;
	//int & c = a;这样是错误的，a只有读权限，但用c引用后变成可以写了，属于权限放大，所以不能这样
	const int& c = a;
	const int & d = b;//这样是正确的，b可以读可以写，用d引用后只能读取，属于权限缩小，所以可以。
}

我们平常的赋值没有权限约束，怎么赋值都行
原因：赋值只是把变量的值拷贝过来了，又重新开辟空间了，不会对原来空间造成影响。

int main()
{
	const int a = 10;
	int b  = 20;
	int c = a;
	const int d = b;
}

引用的使用场景

. 做参数

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

. 做返回值

int& Count()
{
   static int n = 0;
    //static改变n的生命周期，使它和整个程序生命周期一样，
    //如果不这样的话，当返回它的别名时候，函数栈帧销毁，它也被系统回收，
    //所以当用引用变量接收时候，这块空间已经不属于它了。
   n++;
   // ...
   return n;
}

看一下下面代码会出现什么情况

nt& Add(int a, int b)
{
    int c = a + b;
    return c;
}
int main()
{
    int& ret = Add(1, 2);
    Add(3, 4);
    cout << "Add(1, 2) is :"<< ret <<endl;
    return 0;
}

在这里插入图片描述
可以看出，当返回局部变量的引用时候，改局部变量已经被系统回收，所以无法控制它了。

总结：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用
引用返回，如果已经还给系统了，则必须使用传值返回。

传值、传引用效率比较
传值是实参的一份拷贝，而传引用只是实参的别名，没有出现开辟空间，所以效率比较高

#include <time.h>
struct A{ int a[10000]; };
void TestFunc1(A a){}
void TestFunc2(A& a){}
void TestRefAndValue()
{
 A a;
 // 以值作为函数参数
 size_t begin1 = clock();
 for (size_t i = 0; i < 10000; ++i)
 TestFunc1(a);
 size_t end1 = clock();
 // 以引用作为函数参数
 size_t begin2 = clock();
 for (size_t i = 0; i < 10000; ++i)
 TestFunc2(a);
 size_t end2 = clock();
// 分别计算两个函数运行结束后的时间
 cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
 cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

值和引用的作为返回值类型的性能比较
返回值为值的时候，其实是返回变量的一份临时变量（临时变量具有常型），因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当返回值类型非常大时，效率就更低。

#include <time.h>
struct A{ int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a;}
// 引用返回
A& TestFunc2(){ return a;}
void TestReturnByRefOrValue()
{
 // 以值作为函数的返回值类型
 size_t begin1 = clock();
 for (size_t i = 0; i < 100000; ++i)
 TestFunc1();
 size_t end1 = clock();
 // 以引用作为函数的返回值类型
 size_t begin2 = clock();
 for (size_t i = 0; i < 100000; ++i)
 TestFunc2();
 size_t end2 = clock();
 // 计算两个函数运算完成之后的时间
 cout << "TestFunc1 time:" << end1 - begin1 << endl;
 cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

引用和指针的区别
在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。
在这里插入图片描述
引用和指针的不同点

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

内联函数

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调
用建立栈帧的开销，内联函数提升程序运行的效率。
补充知识：将函数调用转成汇编，变成 call + …
在这里插入图片描述

在这里插入图片描述
此处没有call所以没有开辟函数栈帧。

inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建
议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不
是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
在这里插入图片描述

在这里插入图片描述
此处显示了call 说明有函数栈帧的开辟

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

通过以上介绍，你可以发现它和宏很像
宏的优缺点？
优点：
1.增强代码的复用性。
2.提高性能。
缺点：
1.不方便调试宏。（因为预编译阶段进行了替换）
2.导致代码可读性差，可维护性差，容易误用。
3.没有类型安全的检查。
C++有哪些技术替代宏？

常量定义换用const enum
短小函数定义换用内联函数

auto关键字

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

int main(){
	int a = 10;
	auto b = 10;//编译器自动赋予int数据类型
}

auto使用细则

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

int main()
{
    int x = 10;
    auto a = &x;
    auto* b = &x;
    auto& c = x;
    cout << typeid(a).name() << endl;
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;
    *a = 20;
    *b = 30;
     c = 40;
    return 0;
}

在这里插入图片描述

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

auto a = 10, b = 20;
auto c = 20,d = 4.0;//此处会报错，20和4.0类型不同

基于范围for循环

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

void TestFor()
{
int array[] = { 1, 2, 3, 4, 5 };
for(auto& e : array)
     e *= 2;
for(auto e : array)
     cout << e << " ";
return 0;
}

注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。
使用条件：
for循环迭代的范围必须是确定的，对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供
begin和end的方法，begin和end就是for循环迭代的范围。

指针空值nullptr(C++11）

在c++中

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

可以看到NULL有可能被赋成0或void*（0），这样的话有的程序是本意是调用空指针，就也有可能会使用0，
为了避免这种情况c++引入了nullptr关键字来表示空指针
注意·：

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