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

初识C++：入门基础（二）

news 来源：原创 2025/5/10 9:23:57

概述：该篇博客主要介绍C++的缺省函数、函数重载、和引用等知识。

1. 缺省参数

2. 函数重载

3. 引用

3.1 引用的概念和定义

3.2 引用的特性

3.3 引用的使用

3.4 const引用

3.5 指针和引用的关系

4. nullptr

5. 小结

1. 缺省参数

缺省参数是声明或定义函数式为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该醒参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方缺省参数也叫默认参数）

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

全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。

#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;
}
// 半缺省 
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()
{Func1();Func1(1);Func1(1,2);Func1(1,2,3);Func2(100);Func2(100, 200);Func2(100, 200, 300);return 0;
}

带缺省参数的函数调用，C++规定必须从左到右依次给实参，不能跳跃给实参。
函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

// Stack.h
#include <iostream>
#include <assert.h>
using namespace std;
typedef int STDataType;
typedef struct Stack
{STDataType* a;int top;int capacity;
}ST;
void STInit(ST* ps, int n = 4);
// Stack.cpp
#include"Stack.h"
// 缺省参数不能声明和定义同时给 
void STInit(ST* ps, int n)
{assert(ps && n > 0);ps->a = (STDataType*)malloc(n * sizeof(STDataType));ps->top = 0;ps->capacity = n;
}
// test.cpp
#include"Stack.h"
int main()
{ST s1;STInit(&s1);// 确定知道要插⼊1000个数据，初始化时⼀把开好，避免扩容 ST s2;STInit(&s2, 1000);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;
}

// 下⾯两个函数构成重载 
// 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;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的引用可以改变指向。

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++规定临时对象具有常性，所以这里就触发了权限放大，必须要用常引用才可以。

#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;// 编译报错：“初始化”: ⽆法从“double”转换为“int &” // int& rd = d;const int& rd = d;return 0;
}

所谓临时对象就是编译器需要⼀个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象， C++中把这个未命名对象叫做临时对象

int main()
{const int a = 10;// 编译报错：error C2440: “初始化”: ⽆法从“const int”转换为“int &” // 这⾥的引⽤是对a访问权限的放⼤ //int& ra = a;// 这样才可以 const int& ra = a;// 编译报错：error C3892: “ra”: 不能给常量赋值 //ra++;// 这⾥的引⽤是对b访问权限的缩⼩ int b = 20;const int& rb = b;// 编译报错：error C3892: “rb”: 不能给常量赋值 //rb++;return 0;
}

3.5 指针和引用的关系

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

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

4. nullptr

NULL 是一个宏，在传统的C头文件（stddef.h）中，可以看到以下代码：

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

C++中NULL可能被定义为字面常量0，或者C中被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到⼀些麻烦，本想通过f(NULL)调⽤指针版本的 f(int*)函数，但是由于 NULL 被定义成0，调用了f(int x)，因此与程序的初衷相悖。f((void*)NULL ); 调用会报错。
C++11中引⼊nullptr，nullptr是⼀个特殊的关键字，nullptr是⼀种特殊类型的字面量，它可以转换成任意其他类型的指针类型。使⽤nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式地转换为指针类型，而不能被转换为整数类型。

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