C++入门：缺省、重载、引用、auto和for循环语法糖以及NULL和nullptr

最新推荐文章于 2024-08-08 13:30:00 发布

欧阳pear

最新推荐文章于 2024-08-08 13:30:00 发布

阅读量118

点赞数

分类专栏： C++ 文章标签： c++

本文链接：https://blog.csdn.net/Pear549669/article/details/134608362

版权

C++ 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章目录

1. 缺省参数
- 1.1 缺省参数分类
2. 函数重载
- 2.1.1 编译器函数命名规则
3. 引用
4. 内联函数
- 4.1 特性
5. auto 关键字
- 5.1 auto的使用细则
6. 范围for--语法糖
7. NULL 和nullptr

1. 缺省参数

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

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

1.1 缺省参数分类

共有两种分类：

全缺省参数：即函数形参全有缺省值。

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

半缺省参数：即函数形参中部分形参具有缺省值。

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

缺省规则：

半缺省参数必须从函数形参中右往左依次来给出，不能间隔着给。
半缺省函数在调用时，使用半缺参数时应该依次从左往右使用，不支持隔参缺省如Func(1,,2)。
缺省参数不能在函数声明和定义中同时出现。（推荐：当需要声明和定义分离时，缺省参数在声明时出现即可）

//错误表示
// a.h
void Func(int a = 10);
  
  // a.cpp
void Func(int a = 20)
 {}
//正确表示
// a.h
void Func(int a = 10);
  
  // a.cpp
void Func(int a)
 {}

缺省值必须是常量或者全局变量。
C语言不支持。

2. 函数重载

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

参数类型不同：

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

参数个数不同：

// 1、参数个数不同
int Foc()
{
 	cout << "int Foc()" << endl;
 	return 666;
}

int Foc(int x)
{
	cout << "int Foc(int x)" << endl;
 	return x * 10;
}

参数顺序不同：

//参数顺序不同
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;
}

2.1.1 编译器函数命名规则

编译器如何识别重载函数的类型呢？
其实是编译器具有一套函数的修饰规则。如：
在Linux 环境中，函数Add(int int)编译器会修饰成：_Z3Addii

-Z : 前缀
3 ：函数名个数
ii ：形参类型

3. 引用

引用不是新定义一个变量，而是给已存在的变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
比如：李逵，在家称“铁牛”，江湖上人称“黑旋风”。

类型& 引用变量名（对象名） = 引用实体

int a = 10;
int& ra = a; //  定义引用类型
cout << a << endl;
cout << ra << endl;

注意：引用类型必须和引用实体是同种类型的。且对引用变量的修改，也会修改原实体变量。

3.1 引用特性

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

#include <iostream>

using namespace std;
int main()
{
    int a = 10;
    // int& ra;   // 该条语句编译时会出错
    int& ra = a;
    int& rra = a;
    cout << &ra << endl;
    cout << &rra << endl;
    cout << &a << endl;
}

3.2 常引用

引用和指针具有一个共同规则：可以对实体的权限缩小，但不可以权限扩大。

void TestConstRef()
{
    const int a = 10;
    //int& ra = a;   // 该语句编译时会出错，a为常量
    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，b为常量
    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同
    const int& rd = d;
}

3.3 使用场景

做参数

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

做返回值

int& Count()
{
   static int n = 0;
   n++;
   // ...
   return n;
}

注意：

传值和传引用效率比较：传引用的效率比传值的效率高效，究其原因是在传值调用时底层需要拷贝一份数据到栈帧中作为形参而传引用则无需这份步骤。
值和引用作为返回值类型的效率比较：当使用值为返回类型，当返回值小于8字节时，底层寄存器会将值拷贝，并返回上一层栈帧中，而传引用则无需这份步骤

3.4 引用和指针的区别

在语法感念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
但底层原理是，引用是按照指针方式来实现的。

引用和指针的不同点：

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

4. 内联函数

使用inline修饰的函数，其功能和C语言中的#define宏函数类似，究其原因是C++对于C语言宏函数的不安全而衍生出来的。

4.1 特性

使用空间（程序大小）换时间的说法，在编译阶段，会将函数体替换函数调用，缺点：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

注意：内联函数不建议分离声明和定义（可在头文件定义）。且内联函数不进符号表。

5. auto 关键字

在C++11中，auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推倒而得。
实际价值：简化代码，当类型很长时，可以考虑自动推导
typeid(变量名).name()获取变量类型
缺点：

需要熟悉对象返回值类型。
auto不能做形参和声明数组。

int a = 0;
auto b = &a;
auto* c = &a;// auto接*，代表了必须是个指针变量。
auto& d = a; //d = a 的引用

5.1 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 = 1, b = 2; 
auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同

使用注意：

auto不能作为函数的参数，如void Test(auto x);
auto不能直接用来声明数组，如auto arr[] = {1,2,3};
C++11舍去了C++98时的auto用法

6. 范围for–语法糖

对于有范围的数组来说语法糖更加简便与美观，自动依次取数组中数据赋值给e对象，自动判断结束。

for(auto e : array)
{

}

auto e:范围内用于迭代的变量。
array：用于限制e迭代的范围。

使用限定：array必须是明确的数组范围的。

7. NULL 和nullptr

在某些地方NULL可能会被定义为 0，是个宏。而nullptr是个关键字。

void f(int)
{
    cout << "f(int)" << endl;
}
void f(int*)
{
    cout << "f(int*)" << endl;
}

int main()
{
    f(0);
    f(NULL);
    f(nullptr);
    return 0;
}