当前位置：首页 > news >正文

C++入门基础（2）

news 来源：原创 2025/4/24 12:16:56

在这里插入图片描述

Hello~,欢迎大家来到我的博客进行学习！

1.缺省参数

缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方把缺省参数也叫默认参数）
全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。
函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省
值。

有两种调用方式：

#include <iostream>
using namespace std;
void Func(int a = 0)
{cout << a << endl;
}
int main()
{Func(); // 没有传参时，使⽤参数的默认值Func(10); // 传参时，使⽤指定的实参return 0;
}

这样有一定的好处，比如我在前面写的顺序表那里，在不知到插入数据多少的情况下，可以用一个默认值，当有确定的大小情况下，则可以直接输入需要开辟的空间大小。
这里的第四条就是在给缺省参数时，我们只能放在声明，就是放在.h文件中，这是为了防止在声明和定义都有缺省参数时，不知用哪一个的麻烦。
在全缺省的情况下，这里的调用方式多，有四种，但是要注意不能跳跃传参。

#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;
}int main()
{Func1();Func1(1);Func1(1, 2);Func1(1, 2, 3);
}

半缺省则需要至少传一个，缺省值从右往左给。

#include<iostream>
using namespace std;
// 半缺省
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()
{Func2(100);Func2(100, 200);Func2(100, 200, 300);return 0;
}

2.函数重载

C++支持在同⼀作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调用就表现出了多态行为，使用更灵活。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;
}

但是要注意的是返回值不同不构成函数重载。

void fxx()
{}int fxx()
{return 0;
}

下面两个函数构成重载，但是调用f()时，会报错，存在歧义，编译器不知道调用谁。

void f1()
{cout << "f()" << endl;
}void f1(int a = 10)
{cout << "f(int a)" << endl;
}int main()
{Add(10, 20);Add(10.1, 20.2);f();f(10);f(10, 'a');f('a', 10);return 0;
}

3.引用

3.1 引用的概念和定义

引用不是新定义⼀个变量，而是给已存在变量取了⼀个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同⼀块内存空间。比如：水浒传中李逵，宋江叫"铁牛"，江湖上人称"黑旋风"；林冲，外号豹子头；
类型& 引用别名 = 引用对象;
C++中为了避免引入太多的运算符，会复用C语言的⼀些符号，比如前面的<< 和 >>，这里引用也和取地址使用了同⼀个符号&，大家注意使用方法角度区分就可以。（吐槽⼀下，这个问题其实挺坑的，个人觉得用更多符号反而更好，不容易混淆）

#include<iostream>
using namespace std;
int main()
{int a = 0;// 引⽤：b和c是a的别名int& b = a;int& c = a;// 也可以给别名b取别名，d相当于还是a的别名int& d = b;++d;// 这⾥取地址我们看到是⼀样的cout << &a << endl;cout << &b << endl;cout << &c << endl;cout << &d << endl;return 0;
}

这里面一个变量++，其他变量也++，地址是一样的。假设我给孙悟空起一个别名，叫齐天大圣，之后我再给齐天大圣取一个别名，本质上还是孙悟空。

3.2 引用的特性

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

#include<iostream>
using namespace std;
int main()
{int a = 10;// 编译报错：“ra”: 必须初始化引⽤int& ra;return 0;
}

第三点这里我们要注意，这里并非让b引用c，因为C++引用不能改变指向，这里是⼀个赋值。

#include<iostream>
using namespace std;
int main()
{int a = 10;int& b = a;int c = 20;// 这⾥并非让b引⽤c，因为C++引⽤不能改变指向，// 这⾥是⼀个赋值b = c;cout << &a << endl;cout << &b << endl;cout << &c << endl;return 0;
}

3.3引用的使用

引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。
引用返回值的场景相对比较复杂，我们在这里简单讲了⼀下场景，还有⼀些内容后续类和对象章节中会继续深⼊讲解。
引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引用跟其他语言的引用(如Java)是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向，Java的引用可以改变指向。
⼀些主要用C代码实现版本数据结构教材中，使用C++引用替代指针传参，目的是简化程序，避开复杂的指针，但是很多同学没学过引用，导致⼀头雾水。

例如这里交换两个变量的值，在c语言中，我们使用指针来完成这一功能，在c++中可以采用引用来实现。

#include<iostream>
using namespace std;
void Swap(int& rx, int& ry)
{int tmp = rx;rx = ry;ry = tmp;
}
int main()
{int x = 0, y = 1;cout << x << " " << y << endl;Swap(x, y);cout << x << " " << y << endl;return 0;
}

3.4 const引用

可以引用⼀个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。
不需要注意的是类似 int& rb = a * 3 ; double d = 12.34; int& rd = d; 这样⼀些场景下a*3的和结果保存在⼀个临时对象中， int& rd = d 也是类似，在类型转换中会产生临时对象存储中间值，也就是时，rb和rd引用的都是临时对象，而C++规定临时对象具有常性，所以这里就触发了权限放大，必须要用常引用才可以。
所谓临时对象就是编译器需要⼀个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象，C++中把这个未命名对象叫做临时对象。

对于第一点，可以用一下代码进行理解。这里是权限的平移。

#include<iostream>
using namespace std;
int main()
{const int a = 10;// 编译报错：error C2440: “初始化”: ⽆法从“const int”转换为“int &”// 这⾥的引⽤是对a访问权限的放⼤//int& ra = a;// 这样才可以const int& ra = a;return 0
}

当然权限也可以缩小。

#include<iostream>
using namespace std;
int main()
{// 这⾥的引⽤是对b访问权限的缩⼩int b = 20;const int& rb = b;// 编译报错：error C3892: “rb”: 不能给常量赋值//rb++;return 0;
}

const引用我们知道可以引用下面的a，其实const引用也可以引用常量，但是要注意普通引用不可以引用常量。

普通引用不能直接引用表达式，这是一种权限的扩大。表达式的值需要用临时变量或者寄存器储存，而这个临时对象具有const属性，不能修改。

下面这里d的值是可以给c的，但是不能用int&rd对d进行引用，原因也是权限的放大。d的值在给c的时候会把值先给临时对象，然后再给int类型的c，这里会失去精度。同理用int&rd对d进行引用时，会有临时对象，临时对象具有const属性，不能进行修改，用const int& rd = d就可以。

#include<iostream>
using namespace std;
int main()
{int a = 10;const int& ra = 30;// 编译报错: “初始化”: ⽆法从“int”转换为“int &”// int& rb = a * 3;const int& rb = a * 3;double d = 12.34;int c =d;// 编译报错：“初始化”: ⽆法从“double”转换为“int &”// int& rd = d;const int& rd = d;return 0;
}

3.5 指针和引用的关系

C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。

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

指针的使用会更麻烦，功能重叠的部分，使用引用更好一些。

扩展

在语法层，这里的引用不开空间，指针开空间。

#include<iostream>
using namespace std;
int main()
{int a = 1;int& ra = a;int b = 2;int* rb = &b;return 0;
}

在底层：
在这里插入图片描述
先看指针，这里把2mov到b，lea是取地址，把b的地址存到寄存器，再mov，把b的地址mov到rb。

这里我们会发现，指针和引用是一样的。在汇编指令层，没有引用的概念。上层引用语法，汇编层用指针实现。

4. nullptr

NULL实际是⼀个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：
在这里插入图片描述
C++中NULL可能被定义为字面常量0，或者C中被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到⼀些麻烦，本想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，调用了f(int x)，因此与程序的初衷相悖。f((void*)NULL);调用会报错。

#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(int*)函数，但是由于NULL被定义成0，调⽤了f(intx)，因此与程序的初衷相悖。f(NULL);f((int*)NULL);// 编译报错：error C2665: “f”: 2 个重载中没有⼀个可以转换所有参数类型// f((void*)NULL);f(nullptr);return 0;
}