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

C++学习——缺省参数、重载函数、引用

news 来源：原创 2025/5/10 0:33:15

前言

缺省参数的含义很好理解，重载函数是一个很有意思的用法，对比C语言有了很大的改变。

我们之前在C语言中学过指针，一个*对应着一个&，分别是解引用和取地址，那么在C++里也有一个类似的但是它只有一个&，通过这种用法这里就不是取地址的意思了，而是引用的意思，而且比较方便容易使用。

一、缺省参数

1.1概念

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

1.2写法

void Func(int a = 0)//这就是缺省参数
{cout << a << endl;
}
int main()
{Func();//不传参数的时候用函数自己里面的Func(10);//传的时候用显示参数，用指定的参数return 0;
}

这里就是一个缺省参数的写法，比较简单理解。

1.3半缺省

//-----半缺省，从右往左缺省，传参从左往右
void Func(int a , int b = 15, int c = 20)
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl;
}
int main()
{//Func();Func(1);     //1	15	20Func(1,2);   //1	2	20可以从左到右传依次传参Func(1,2,3); //1	2	3return 0;
}

半缺省的实现就是从左往右走，没传入参数的就按照函数内的参数输出。

1.4使用

这里是一个栈。

struct Stack
{int* a;int top;int capacity;
};void StackInit(struct Stack* pst,int defaultCapacity=4)
{pst->a = (int*)malloc(sizeof(int) * defaultCapacity);if (pst->a){perror("malloc fail");return;}pst->top = 0;pst->capacity = 4;
}int main()
{struct Stack st;StackInit(&st,100);StackInit(&st);return 0;
}

如果没有defaultCapacity，那就需要不断扩容，效率低下，但我们不知道要申请多少内存，所以先给4个，不够用再扩容，默认情况下开少一点，如果想控制就显示的传入参数。

这里注意：

声明和定义不能同时给缺省，因为这时候就不知道按照谁的来了

二、重载函数

2.1.概念

我们知道C语言不允许同名函数的出现,c++则可以，自动匹配类型,构成重载需要没有歧义。

函数重载是函数中的一种特殊的情况，C++允许在同一作用域中声明几个功能类似的同名函数。这些同名函数形参列表（参数个数或类型或类型顺序）不同，常用来处理实现功能类似数据类型不同的问题,返回值没有要求

2.2类型

//---类型
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;
}
int main()
{cout << ADD(1, 2) << endl;cout << ADD(1.1, 2.2) << endl;return 0;
}

这里返回的类型不同，传入形参的类型也不同，所以可以实现函数重载，不会报错。

2.3参数

//----参数
void Func()
{cout << "Func()" << endl;
}
void Func(int a)
{cout << "Func(int a)" << endl;
}

一个有参数，一个没有参数，所以可以用函数重载，不会报错。

2.4顺序

//----顺序
//也可以认为是类型不同
void f(int a, char b)
{cout << "f(int a, int b)" << endl;
}
void f(char b, int a)
{cout << "f(int a, int b)" << endl;
}

这里是顺序不同，当然也可以认为是类型不同，因为两个形参的类型发生了变化，所以可以用函数重载，不会报错。

2.5问题

当无参调用的时候就会发生歧义

//----问题：无参调用存在歧义
void f()
{cout << "f()" << endl;
}
void f(int a=0)
{cout << "f(int a=0)" << endl;
}
int main()
{f();//重载调用不明确return 0;
}

这里就会出现一个报错，说是重载调用不明确，也就是不知道用哪一个函数了。所以要注意一下。

2.6原理

实际上，函数重载的实现是和它编译器汇编命名规则有关，C语言为什么不能函数重名，因为在C语言中，汇编函数的命名就是函数本身的名字，没有发生改变，所以肯定会发生冲突。而在C++中，汇编函数的命名是重新用一种函数命名的方法，它结合了形参，使两个函数名发生了不同，所以调用的时候不会发生冲突从而实现了函数重载。

三、引用

1、引用是什么？

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

在C++中，引用是一种别名，用于引用已存在的变量或对象。它允许我们通过一个变量名来访问另一个变量的值，而无需使用指针。

引用通常用于函数参数、函数返回类型、以及作为对象的别名。引用在声明时必须进行初始化，一旦初始化后，它将一直引用同一个对象，无法改变引用的目标。引用在使用上类似于原始变量，但是对引用的操作实际上是对原始变量的操作。引用的主要优点是可以避免拷贝大型对象，提高程序的效率。

什么是别名呢，比如你是李白，你又字太白，所以我可以管你叫李白，也可以管你叫“李太白”，但是这两个名字是否是一个人呢？当然如此，就是一个对象，有不同的叫法。

2、引用的使用方法

我们直接给出代码：

int main()
{int a = 0;int& b = a;int& c = b;a = 10;cout << a << " " << b << " " << c << " " << endl;cout << &a << " " << &b << " " << &c << " " << endl;return 0;
}

这里给出了一个变量a，引用b，也就是a的别名可以是b，引用c，b的别名是c，而b又是a的别名，所以c是a的别名，b和c实际上就是a，这里a赋给10，那么输出来的三个变量也都是10。我们不妨可以运行一下：

我们可以看见都是a的地址，他们也都是10，这就是引用。

3、引用特性

引用这里也有几个要注意的特性：

1、引用在定义的时候必须要初始化

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

这里要是不初始化的话就会报错。

2、一个变量会有多个引用

比如我们之前的代码：

    int a = 0;int& b = a;int& c = b;

这里a变量就有两个引用，分别是b和c。

3、引用一旦引用了一个实体，就不能再引用别的

int a = 10;
int& b = a;
int c = 5;
int& b = c;
cout << a << " " << b << " " << c << " " << endl;
return 0;

这里我们b先引用了a，然后又定义了一个c的变量，再把b引用c，这时候如果我们运行程序的话，就会发现报错。

4、与指针对比

我们以前可能写过两个数交换的函数，那时候用的是指针交换：

void swap(int* a, int* b)
{int tmp = *a;*a = *b;*b = tmp;
}
int main()
{int a = 10;int b = 30;cout << "before::" << a << " " << b << endl;swap(&a, &b);cout << "after::" << a << " " << b << endl;return 0;
}

我们通过两个数的指针传入地址实现传址交换通过交换：

这里我们就可以用C++来实现，因为别名都是一个对象的，所以如果引用传入的参数，那么自函数里的参数就是主函数传入参数的别名，都是同一个变量，变相的实现了传址：

void swap(int& a, int& b)
{int tmp = a;a = b;b = tmp;
}
int main()
{int a = 10;int b = 30;cout << "before::" << a << " " << b << endl;swap(a, b);cout << "after::" << a << " " << b << endl;return 0;
}

这里运行之后还是符合的：

如果这里是传的指针呢？

void swap(int* a, int* b)
{int tmp = *a;*a = *b;*b = tmp;
}
int main()
{int x = 10;int y = 30;int* a = &x;int* b = &y;cout << "before::" << *a << " " << *b << endl;swap(*a, *b);cout << "after::" << *a << " " << *b << endl;return 0;
}

这里就是参数传入的是指针，我们依旧可以用引用来实现：

把指针引用可以吗，当然可以了，请看下面的代码：

void swap(int*& a, int*& b)
{int tmp = *a;*a = *b;*b = tmp;
}
int main()
{int x = 10;int y = 30;int* a = &x;int* b = &y;cout << "before::" << *a << " " << *b << endl;swap(a, b);cout << "after::" << *a << " " << *b << endl;return 0;
}

这里就直接把指针引用了，结果运行后还是之前的：

指针和引用的不同点：

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

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

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

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

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

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

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

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

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

5、使用场景

5.1引用作参数

引用作为参数就是为了提升效率，针对两种情况最适合用引用来作为参数，第一个是大对象，第二个是深度拷贝对象。深度拷贝是指在拷贝对象时，不仅要复制对象的成员变量的值，还需要为新对象分配独立的内存空间，并将原对象的值复制到新对象的内存空间中。这里先接触大对象，后期再接触深度拷贝。

5.1.1大对象作为引用参数

大对象是什么意思，就是通过sizeof后，比较大的对象。

我们可以用下面的代码进行测试：

struct A { int a[10000]; };
void test1(A a) {}
void test2(A& a){}
void testref()
{A a;//以值作为函数参数size_t begin1 = clock();for (size_t i = 0; i < 10000; ++i)test1(a);size_t end1 = clock();//以引用作为函数参数size_t begin2 = clock();for (size_t i = 0; i < 10000; ++i)test2(a);size_t end2 = clock();//分别计算两个函数运行结束后的时间cout << "test1_time::" << end1 - begin1 << endl;cout << "test2_time::" << end2 - begin2 << endl;
}int main()
{testref();return 0;
}

这里定义了一个结构体，里面有一个四万字节的整形数组，定义了两个函数，一个是单独的传值，一个用了引用，这里我们可以通过time库函数计时来看到明显的区别：

可以看到时间效率的快慢，对象越大，代价越大。

5.2引用作为返回值

5.2.1使用

我们先看这一块代码：

int Func()
{static int n = 0;n++;return n;
}
int main()
{int a=Func();return 0;
}

Func函数内变量n是在静态区的，当函数调用后n++，但这里不是直接n赋给了主函数里的a，而是通过一个中间的一个寄存器或者其他临时变量接收，然后再传给a，函数栈帧也销毁。

这样我们就可以知道，中间的步骤也是需要时间的，如何才能绕过中间的寄存器或者临时变量呢？这里就可以用引用作为返回值。

int& Func()
{static int n = 0;n++;return n;
}
int main()
{int a=Func();return 0;
}

函数返回的是n，这里引用了n，赋给了a，所以返回值n就是a的一个别名，直接跳过了中间的一系列操作。

如果不生成临时变量好处就是减少了拷贝，提高了效率，在面对大对象的时候影响会很大

我们同样可以用time库来测试一下效率：

struct A { int a[10000]; };
A a;
A test1() { return a;}//值返回
A& test2() { return a;}//引用返回
void testref()
{//以值作为函数返回值类型size_t begin1 = clock();for (size_t i = 0; i < 10000; ++i)test1();size_t end1 = clock();//以引用作为函数返回值类型size_t begin2 = clock();for (size_t i = 0; i < 10000; ++i)test2();size_t end2 = clock();//分别计算两个函数运行结束后的时间cout << "test1_time::" << end1 - begin1 << endl;cout << "test2_time::" << end2 - begin2 << endl;
}

这里就是通过值返回和引用返回，运行下来可以看到明显的差距：

5.2.2引用作为返回值的注意点

我们思考一个问题：函数栈帧的创建和销毁应该是在一个作用域内的，如果出了这个作用域，就被系统回收销毁了，那么我们在传值引用的时候会不会出现问题？

答案是有可能会的，而且很不安全，所以一定要谨慎使用，这完全取决于栈帧销不销毁，取决于系统，栈帧不销毁我们就可以用，但如果销毁了我们就只能用传值。

我们在用返回值引用的时候，有以下几种情况可以使用：

1、static静态区变量

2、全局变量

3、malloc内存

5.2.3引用返回用于读写修改

我们定义了一个顺序表，这里用的静态顺序表方便演示：

struct SeqList
{int a[100];size_t size;
};

如果提供一个函数可以对它修改而且还可以获取当前修改的地方，怎么写？

int& SLAt(SeqList& ps, int pos)
{assert(pos < 100 && pos >= 0);return ps.a[pos];
}

通过引用返回就可以实现，这里引用的是当前要修改位置的变量，通过以下操作就可以实现：

int main()
{SeqList s;SLAt(s, 0) = 1;cout << SLAt(s, 0) << endl;SLAt(s, 0) += 5;
}

这里就是表的第0个位置修改成1，第0个位置加上5。

5.2.4权限问题

引用返回也有权限问题，这里先说结论：

引用的过程中，权限不能放大，可以缩小或者平移

//引用的过程中，权限不能放大const int a = 0;int& b = a;

这里原来a是常变量，引用后是一个没有限制的整形，所以权限发生了变大，是不能的。

//	//引用过程中，权限可以平移或者缩小int x = 0;int& y = x;

还有一种就是修改的方法：

	int& y = x;const int& z = x;//缩小的是z作为别名的权限，x作为别名z的时候不能修改，当为x的时候可以修改，这里可以修改x,y来改变z，但是不能通过z来改变

这里z因为是常量，所以不能进行修改，但是可以通过x来修改，可以通过x和y来修改z的值。

下面这段代码可不可以运行，可以，因为会发生整形提升：

int main()
{double dd = 1.11;int ii = dd;
}

当我们用引用呢？

int main()
{double dd=1.11;int& rii = dd;//const int& rii = dd;
}

答案是不能。也许你会想以你为是因为不同类型的原因，当然这也是一部分原因，但还有另一部分原因，就是在这里不同类型赋值的时候，中间会出现一个临时变量，而这个临时变量是有常性的，所以不能。如果给上一个const就可以实现。

5.2.5总结

1、基本任何场景都可以用引用传参
2、谨慎用引用做返回值，出了函数作用域，对象不在了，就不能用引用返回，还在就可以用引用返回.

总结

今天主要对缺省参数进行了了解，重载函数进行了了解，重点对引用进行了学习。

目录

前言