【C++】---入门知识总结

已于 2022-09-21 23:49:57 修改
阅读量123 收藏 1
点赞数 2
分类专栏： C++ 文章标签： c++
于 2022-09-20 00:44:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_52563203/article/details/126944904
版权

文章目录

命名空间

在之前学的C语言中，定义多个变量的时候是不能出现重名变量/函数/类型的，就会导致当一个大项目被多个人编写时难免会出现同名冲突的情况因此在C++中做出了优化，就有了命名空间这个概念。可以简单的理解成：不同的命名空间里相同名字的变量/函数/类型并不会引发冲突

命名空间的定义

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

例如：

namespace a
{
	// 命名空间中可以定义变量/函数/类型
    int rand = 10;
    int Add(int left, int right)
    {
    	return left + right;
    }
   
    struct Node
    {
        struct Node* next;
        int val;
    };
}

命名空间里面是可以嵌套另一个空间的

namespace N1
{
    int a;
    int b;
    int Add(int left, int right)
    {
    	return left + right;
    }
    namespace N2
    {
        int c;
        int d;
        int Sub(int left, int right)
        {
       		return left - right;
        }
	}
}

同一个工程里可以允许存在多个相同的命名空间，编译器最后会把所有同名的空间合并成一个命名空间

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

命名空间的使用

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

当我们需要用到命名空间里的内容时就有三种方法可以访问

  1. 利用using namespace std，这个的意思是将std空间释放开来，所有的内容都可以随时使用，比较方便。但是当工程量较大时会容易出错
  2. 利用部分展开，例如using std :: cout，这样我们就可以随时使用cout这个函数了
  3. 在每一次使用时都需要加上命名空间名称和双冒号，std :: cout << hello world << std :: endl

C++输入与输出

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

缺省参数

缺省参数的概念

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

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

缺省参数的分类

全缺省参数

也就是所有的参数全部都有默认值

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

半缺省参数

这里要注意

  1. 半缺省参数必须从右往左依次来给出，不能间隔着给
  2. 缺省参数不能在函数声明和定义中同时出现
  3. 缺省值必须是常量或者全局变量
  4. C语言不支持
void Func(int a, int b = 10, int c = 20)
{
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
    cout<<"c = "<<c<<endl;
}

函数重载

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

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

// 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;
}
int main()
{
    Add(10, 20);
    Add(10.1, 20.2);
    f();
    f(10);
    f(10, 'a');
    f('a', 10);
    return 0;
}

这里要注意：顺序不同必须是不同类型的顺序不同，而不能相同的类型顺序不同

名字修饰

在C++中满足函数重载的同名函数的名字修饰是不同的，例如：int Add(int a, int b)和int Add(char a, char b)

在g++编译完成后前者的名字修饰为（_Z3Addii）后者为（__Z3Addcc）。所以就能够实现函数重载

引用

引用的概念

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

例如：在学校老师会叫某位同学的全名“张三”，在家里父母会叫小名“三儿”，在宿舍同学会叫绰号“小张”，这三种名称指的都是同一个人

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

int main()
{
	int a = 10;
	int& ra = a;
	int& rra = a;
	return 0;
}

image-20220919163001176

可以看到三个名称指向的地址都是同一个，也就是说ra和rra都是变量a的别名

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

引用的特性

  1. 引用在定义时必须初始化
  2. 一个变量可以有多个引用
  3. 引用一旦引用一个实体，再不能引用其他实体

image-20220919163455654

常引用

image-20220919164608951

要注意权限只能缩小和不变，不能放大

引用的使用场景

做参数

引用做参数的好处：1、减少拷贝，提高效率 2、输出型参数，形参修改实参也修改了

由于函数调用结束后，函数的栈空间就会销毁也就是返回值就会销毁，所以在栈销毁前，函数的返回值会拷贝到一个临时的空间中，就会浪费空间，如果是用引用的话就不用拷贝临时空间。

对于引用而言，形参改变实参也会随着改变，例如：

void swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

int main()
{
	int a = 10, b = 20;
	swap(a, b);
	cout << "a = " << a << " " << "b = " << b << endl;
	return 0;
}

image-20220919165627895

在之前如果想让两个变量值交换，我们需要改变它们的地址，有了引用之后就不需要那么麻烦了。

做返回值

int& count()
{
	static int n = 0;
	n++;
	return n;
}

int main()
{
	int ret = count();
	cout << ret << endl;
	return 0;
}

image-20220919170415445

可以看到，代码里面用了static修饰了局部变量，那如果不用static修饰会变成怎么样呢

static修饰的变量是属于静态的，也就是说当函数调用完成后，空间销毁后这个变量是不会被销毁的

因为这个变量是在静态区中存放的，那么空间销毁意味着什么呢

空间销毁并不会真正意义上的销毁这块空间，只是这块空间的使用权不再是我们的了

我们可以再一次进行访问，但是访问的数据会是随机的

image-20220919171047909

可以看到，当我们第二次访问时，数据已经变成了一个随机值

所以当我们用引用做返回值时需要注意

  1. 出了函数作用域，返回的变量不存在了，不能用引用返回，引用返回的结果是未定义的
  2. 出了函数作用域，返回的变量是存在的，才能用引用返回

用引用做返回值的好处有

  1. 减少拷贝，提高效率
  2. 修改返回值

传值和传引用的效率比较

下面来看一段代码

struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
//值传参
void TestFunc3(A a) {}
//引用传参
void TestFunc4(A& 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;
}

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

int main()
{
	TestReturnByRefOrValue();
	TestRefAndValue();
	return 0;
}

以上代码是查看相同的数据量时，传值和传引用的效率对比

image-20220919172053694

可以看出，传引用比传值还是快的

引用和指针的区别

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

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

引用和指针的不同点:

  1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

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

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

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

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

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

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

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

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

内联函数

概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

也就是说，函数在调用时会建立栈帧，如果一个小函数需要调用很多次那就要多次开辟新的栈帧从而导致效率的降低，那这时用inline修饰后，函数在调用时就不会开辟栈帧，而是直接将函数展开。

特性

  1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
  2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性
  3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到

内联函数相对于C语言中的宏定义来说优化了不少，宏的缺点

  1. 不方便调试宏。（因为预编译阶段进行了替换）
  2. 导致代码可读性差，可维护性差，容易误用。
  3. 没有类型安全的检查

使用内联函数就可以有效地增强代码的复用性，提高性能。当然在C++中也会使用const，enum去代替宏的使用

auto关键字

随着程序越来越复杂，程序中用到的类型也越来越复杂，会出现很难拼写的类型，含义不明确导致容易出错的类型

这时就出现了auto关键字，这个关键字的作用就是自动识别变量的类型

int a = 10;
auto b = a;

这里的b就会自动识别为创建的时int类型

使用时也需注意几点

  1. 使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型
  2. 用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
  3. 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量
  4. auto不能作为函数的参数 不能直接用来声明数组

基于范围的for循环

在C语言中如果需要用for循环去遍历一个数组

void TestFor()
{
    int a[] = { 1, 2, 3, 4, 5 };
    for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    a[i] *= 2;
    for (int* p = a; p < a + sizeof(a)/ sizeof(a[0]); ++p)
    printf("%d ",*p);
}

在C++中对于一个有范围的集合而言，or循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围 ，就可以写为

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

与普通循环类似，可以用continue结束本次循环，也可以用break结束循环

指针空值nullptr

在C++中NULL这个宏有个小bug，这里定义了NULL == 0而不是（(void*)0）,因此在使用时并能看作是一个指针，这时候就要使用到新的标准，nullptr代表的就是一个空指针

总结

在这里插入图片描述
C++学习正式开始，要学的知识点比C语言多了很多，也更加的深奥

一步一个脚印，多敲代码多刷题👍

评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值