C++入门（part 2）

2024-09-07 01:36
文章标签 c++ 入门 part

本文主要是介绍C++入门（part 2），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

前言

在前文我们讲解了C++的诞生与历史，顺便讲解一些C++的小语法，本文会继续讲解C++的基础语法知识。

1. 缺省参数

1.1缺省参数的概念

缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调⽤该函数时，如果没有指定实参则采⽤该形参的缺省值，否则使用指定的实参。（有些地⽅把缺省参数也叫默认参数）
在这里插入图片描述

1.2 缺省参数的分类

缺省参数分为全缺省和半缺省参数，全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。

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

半缺省参数的规定

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

#include<iostream>
using namespace std;void Func1(int a, int b = 10, int c = 20);
void Func2(int a, int b, int c = 10);错误写法
void Func3(int a = 10, int b, int c = 20);
void Func4(int a = 10, int b = 20, int c):

Func3 和 Func4都是错误写法，不能跳跃着给缺省值，也不能从左往右给缺省值，这是语法的规定。

传参的规定

带缺省参数的函数调⽤，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);Func1(, 2, ) //不能跳着传参//半缺省的传参方式 必须要传一个值给aFunc2(100);Func2(100, 200);Func2(100, 200, 300);return 0;
}

在这里插入图片描述

声明与定义的规定

函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。
在这里插入图片描述
其实也很好理解，如果声明和定义的缺省参数不一样，这时候该以谁为准呢？
所以为了避免这个情况的发生，C++就规定了必须在函数声明给缺省值。

1.3 缺省函数的使用

#include<iostream>
using namespace std;int* Func(int n = 0)
{int* tmp = (int*)malloc(n * sizeof(int));
}

如上，我们Func函数是一个专门开空间的函数，当我们知道要开多大的空间时，就可以传具体的参数给n，我们不知道时，就什么也不传，这时n就会使用0，就相当于没有开辟空间。

更好理解缺省参数
你可以将缺省参数看成备胎，实在没有参数的时候，a才会使用缺省参数，一但有其他参数了，那么a就会毫不犹豫的放弃缺省参数，使用其他的参数。

2. 函数重载

2.1 函数重载的概念

相较于C语言，C++支持在同⼀作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。 这样C++函数调用就表现出了多态行为，使用更灵活。C语言是不支持同⼀作用域中出现同名函数的。

这个语法很有用，举个例子，在做加法这个函数时，我们在C语言要写两个不同名字的函数来实现整数和浮点数的加法运算。

C语言：

#include<stdio.h>
int Add_int(int a, int b)
{int c = a + b;return c;
}double Add_double(double a, double b)
{double c = a + b;return c;
}int main()
{Add_int(1, 2);Add_double(1.1, 2.2);return 0;
}

这样显得很麻烦，而且还要花费不必要的精力来辨别，然而C++支持在同一作用域中出现同名函数，我们就可以这样写。

C++：

#include<iostream>
using namespace std;
int Add(int a, int b)
{cout << "int Add_int(int a, int b)" << endl;return a + b;
}double Add(double a, double b)
{cout << "double Add_double(double a, double b)" << endl;return a + b;
}int main()
{Add(1, 2);Add(1.1, 2.2);return 0;
}

在这里插入图片描述

2.2 形参的不同

前面说过，C++支持在同⼀作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。
上文展示的就是一个不同：形参类型不同

#include<iostream>
using namespace std;
int Add(int a, int b)
{cout << "int Add_int(int a, int b)" << endl;return a+b;
}double Add(double a, double b)
{cout << "double Add_double(double a, double b)" << endl;return a+b;
}

第二种：形参个数不同

#include<iostream>
using namespace std;
//形参个数不同
void f()
{cout << "void f()" << endl;
}void f(int a)
{cout << "void f(int a)" << endl;
}

第三种：形参类型顺序不同

#include<iostream>
using namespace std;
//形参类型顺序不同
void f(int a, char b)
{cout << "void f(int a, char b)" << endl;
}void f(char a, int b)
{cout << "void f(char a, int b)" << endl;
}

汇总

#include<iostream>
using namespace std;
//形参类型不同
int Add(int a, int b)
{cout << "int Add_int(int a, int b)" << endl;return a+b;
}double Add(double a, double b)
{cout << "double Add_double(double a, double b)" << endl;return a+b;
}//形参个数不同
void f()
{cout << "void f()" << endl;
}void f(int a)
{cout << "void f(int a)" << endl;
}//形参类型顺序不同
void f(int a, char b)
{cout << "void f(int a, char b)" << endl;
}void f(char a, int b)
{cout << "void f(char a, int b)" << endl;
}
int main()
{Add(1, 2);Add(1.1, 2.2);cout << endl;f();f(1);cout << endl;f(1, 'a');f('a', 1);cout << endl;return 0;
}

在这里插入图片描述

2.3 函数重载的注意事项

  1. 函数的类型（返回值的类型）不同不能作为重载的条件，因为在调用的时是无法区分的。
  2. 缺省函数与无参数函数，他们能构成函数重载，但是在调用的时候会报错，因为编译器不知道该调用谁
#include<iostream>
using namespace std;
// 下面两个f1()虽然构成了重载函数，但是调⽤时，会报错，存在歧义，编译器不知道调⽤谁
void f1()
{cout << "void f1()" << endl;
}void f1(int a = 10)
{cout << "void f1(int a = 10)" << endl;
}int main()
{f1();return 0;
}

在这里插入图片描述

3. 引用

3.1 引用的概念和定义

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

#include<iostream>
using namespace std;int main()
{int a = 0;//引用：b是a的别名int& b = a;//也可以给别名起别名，c相当于还是a的别名int& c = b;int& d = c;d++;//在这里可以看到地址都是一样的cout << "&a = " <<& a << endl;cout << "&b = " << &b << endl;cout << "&c = " << &c << endl;cout << "&d = " << &d << endl;return 0;
}

在这里插入图片描述
C++中为了避免引⼊太多的运算符，会复⽤C语言的⼀些符号，比如<<和>>，这样引用也和取地址使用了同⼀个符号&，注意使用方法角度区分就可以。

引用的使用（初步使用）

#include<iostream>
using namespace std;//指针版
void swap(int* rx, int* ry)
{int tmp = *rx;*rx = *ry;*ry = tmp;
}//引用版
void swap(int& rx, int& ry)
{int tmp = rx;rx = ry;ry = tmp;
}int main()
{int x = 1;int y = 0;swap(&x, &y);cout <<"x = " << x << ' ' << "y = " << y << endl;x = 1;y = 0;swap(x, y);cout << "x = " << x << ' ' << "y = " << y << endl;}

在这里插入图片描述

我们可以看到他们完成的功能都是一样的，都是完成交换的任务，但是指针版我们是需要传地址，也就是要多打一个&，而引用版不需要，人都是懒的，能少打一个字符就少打一个字符；所以我们在日常训练时，就可以用引用来替代指针（其实C++祖师爷早就看C语言的指针不爽了）。

3.2 引用的特性

  1. 引用在定义时必须初始化
    在这里插入图片描述

  2. 一个变量可以有多个引用

#include<iostream>
using namespace std;int main()
{int x = 0;int& a = x;int& b = x;return 0;
}
  1. 引用一但引用了一个实体，就不能引用其他实体

在这里插入图片描述
所以C++实现链表的时候还是要使用指针，这也就代表了在C++中引用和指针是相辅相成的。

3.3 引用的使用

  1. 引用主要用于引用传参和引用做返回值中拷贝次数，提高效率
#include<iostream>
using namespace std;
//传值传参
void func1(int a)
{}
//传引用传参
void func1(int& a)
{}//传值返回
int func2()
{}
//传引用返回
int& func3()
{}
  1. 改变引用来改变被引用对象
int main()
{int a = 0;int& b = a;int& c = a;int& d = b;++d;return 0;
}

在这里插入图片描述
在这里插入图片描述

  1. 引用返回的小案例（修改栈顶数据）

主要函数

#include<iostream>
#include<assert.h>
using namespace std;
typedef int STDataType;
typedef struct Stack
{STDataType* a;int top;int capacity;
}ST;//初始化
void STInit(ST& rs, int n = 4)
{rs.a = (STDataType*)malloc(n * sizeof(STDataType));rs.top = 0;rs.capacity = n;
}// 入栈
void STPush(ST& rs, STDataType x)
{assert(rs.a);// 满了，扩容if (rs.top == rs.capacity){printf("扩容\n");int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;STDataType * tmp = (STDataType*)realloc(rs.a, newcapacity *sizeof(STDataType));if (tmp == NULL){perror("realloc fail");return;}rs.a = tmp;rs.capacity = newcapacity;}rs.a[rs.top] = x;rs.top++;
}//取栈顶数据
int STTop(ST& rs)
{assert(rs.top > 0);return rs.a[rs.top - 1];
}

如果我们的返回值不是引用，那么我们是不能对函数的返回值进行直接的修改。
在这里插入图片描述

但如果STTop返回的是引用，那么我们就可以直接对返回值进行修改。

int& STTop(ST& rs)
{assert(rs.top > 0);return rs.a[rs.top - 1];
}

在这里插入图片描述

3.4 const引用

  1. 当你引用const修饰的对象时，必须要用const来修饰引用，const引用也可以引用普通对象，因为对象的访问权限可以缩小，但不能放大。

在这里插入图片描述
编译报错：error C2440 : “初始化” :无法从“const int”转换“int& ”
这里的引用是对a访问权限的放大，需要这样改。

#include<iostream>
#include<assert.h>
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>
#include<assert.h>
using namespace std;
int main()
{//	我们可以进行权限的缩小，但不能放大int b = 20;const int& rb = b;// 这时rb的权限就是仅读不可写的状态，我们不能对rb进行修改rb++;//	b的权限并没有发生改变，还是可读可写的状态b++;return 0;
}

在这里插入图片描述

  1. 需要注意的是类似int& ra = a*3; double d = 12.34; int& rd = d这样的一些场景下；a*3的结果会保存在一个临时对象，int& rd = d也是类似的，在类型转换中也会在临时对象中存储一个临时的中间值，也就是说，ra 和 rd引用的都是一个临时对象，然而C++规定，临时对象就有常属性，所以这里就出现了权限放大，那么久必须用const修饰的引用才可以
int main()
{int a = 3;int& ra = (a * 3);double d = 12.34;int& rd = d;
}

在这里插入图片描述
正确引用：

#include<assert.h>
using namespace std;int main()
{int a = 3;//int& ra = a(a * 3);const int& ra = (a * 3);double d = 12.34;//int& rd = d;const int& rd = d;
}

注：所谓临时对象，其实就是编译器需要一个空间来暂存表达式的求值结果时临时创建的一个未命名的对象，C++把这个未命名对象称为临时对象。

3.5 指针和引用的关系

虽然引用和指针从汇编的角度看，他们是一样的，但是他们之间还是有些不同的。
在这里插入图片描述

  1. 语法概念上引用是给一个变量取别名并不会开空间，而指针是存储一个变量地址，要开空间
  2. 引用在定义时必须初始化，而指针是建议初始化，并不是必须
  3. 引用在引用了一个对象后，不能再引用其他对象；而指针可以不断的改变指向的对象
  4. 引用可以直接访问被引用的对象，而指针访问对象需要进行解引用的操作
  5. 对他们进行sizeof的含义不同，引用结果为引用类型的大小，而指针始终是地址空间所占的字节个数（32位是4个字节，64位是8个字节）
  6. 指针很容易出现空指针和野指针的问题，引用很少会出现，所以引用使用起来会相对安全一些。

4.结语

本文进一步讲解了c++基础知识，讲解了缺省参数的概念、分类和使用；讲解了函数重载的概念、重载的分类以及注意事项；讲解了引用的概念、特点以及与指针的关系。

最后感谢您能阅读完此片文章，如果有任何建议或纠正欢迎在评论区留言，也可以前往我的主页看更多好文哦(点击此处跳转到主页)。
如果您认为这篇文章对您有所收获，点一个小小的赞就是我创作的巨大动力，谢谢！！！

这篇关于C++入门（part 2）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1143679。

相关文章

C++中实现调试日志输出

C++中实现调试日志输出

《C++中实现调试日志输出》在C++编程中,调试日志对于定位问题和优化代码至关重要,本文将介绍几种常用的调试日志输出方法,并教你如何在日志中添加时间戳,希望对大家有所帮助... 目录1. 使用 #ifdef _DEBUG 宏2. 加入时间戳：精确到毫秒3.Windows 和 MFC 中的调试日志方法MFC
阅读更多...
深入理解C++ 空类大小

深入理解C++ 空类大小

《深入理解C++空类大小》本文主要介绍了C++空类大小,规定空类大小为1字节,主要是为了保证对象的唯一性和可区分性,满足数组元素地址连续的要求,下面就来了解一下... 目录1. 保证对象的唯一性和可区分性2. 满足数组元素地址连续的要求3. 与C++的对象模型和内存管理机制相适配查看类对象内存在C++中，规
阅读更多...
在 VSCode 中配置 C++ 开发环境的详细教程

在 VSCode 中配置 C++ 开发环境的详细教程

《在VSCode中配置C++开发环境的详细教程》本文详细介绍了如何在VisualStudioCode（VSCode）中配置C++开发环境,包括安装必要的工具、配置编译器、设置调试环境等步骤,通... 目录如何在 VSCode 中配置 C++ 开发环境：详细教程1. 什么是 VSCode？2. 安装 VSCo
阅读更多...
C++11的函数包装器std::function使用示例

C++11的函数包装器std::function使用示例

《C++11的函数包装器std::function使用示例》C++11引入的std::function是最常用的函数包装器,它可以存储任何可调用对象并提供统一的调用接口,以下是关于函数包装器的详细讲解... 目录一、std::function 的基本用法1. 基本语法二、如何使用 std::function
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
【C++ Primer Plus习题】13.4

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<
阅读更多...
C++包装器

C++包装器

包装器 在 C++ 中，“包装器”通常指的是一种设计模式或编程技巧，用于封装其他代码或对象，使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍，可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型： 1. 函数包装器 函数包装器用于封装一个或多个函数，使其接口更统一或更便于调用。例如，std::function 是一个通用的函数包装器，它可以存储任意可调用对象（函数、函数
阅读更多...
C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页： 南桥几晴秋 🌈C++专栏： 南桥谈C++ 🌈C语言专栏： C语言学习系列 🌈Linux学习专栏： 南桥谈Linux 🌈数据结构学习专栏： 数据结构杂谈 🌈数据库学习专栏： 南桥谈MySQL 🌈Qt学习专栏： 南桥谈Qt 🌈菜鸡代码练习： 练习随想记录 🌈git学习： 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...
06 C++Lambda表达式

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获：包含零个或者多个捕获符的逗号分隔列表 模板形参：用于泛型lambda提供个模板形参的名
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2