【C++】C++入门（上）

已于 2024-01-24 19:44:41 修改
阅读量827 收藏 25
点赞数 20
文章标签： c++ java 开发语言
于 2024-01-23 17:14:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77578940/article/details/135776696
版权

文章目录

前言

C++在C语言的基础上扩展而来，兼容C语言，解决了C语言的一些弊端与缺陷，并且容纳了面向对象编程思想，拥有许多强大实用的库，以及编程范式

今天我们先来了解学习C++是如何对C语言的一些设计缺陷进行优化的

命名空间

命名空间旨在解决命名冲突的问题，包括程序员与库、程序员与程序员之间的命名冲突

程序员与库的命名冲突是指：程序员创建的变量或者函数与库中的变量或者函数发生命名冲突
而程序员与程序员的命名冲突就是两个程序员的命名发生冲突，通常发生在项目合作中

首先来看下面一段代码

#include <stdio.h>

int rand = 1;
int main()
{
	printf("%d", rand);
	return 0;
}

rand是全局变量，在局部函数中输出rand，没有问题，下面对代码稍作修改，包含头文件stdlib.h

#include <stdio.h>
#include <stdlib.h>

int rand = 1;
int main()
{
	printf("%d", rand);
	return 0;
}

运行发生了报错：

image-20240117212324853

rand发生重定义，我们知道 ，程序预处理阶段头文件将会展开，而头文件 stdlib.h 中包含函数 rand()，那么 rand() 就与全局变量 rand 发生命名冲突，导致重定义错误

在解决上面的问题之前，我们先来看一些前置知识

编译器在进行搜索时，会遵循以下原则：

  1. 搜索局部域
  2. 搜索全局域
  3. 指定一个域，如果指定了，优先去搜索指定域，然后是局部，全局

接着看以下代码：

#include <stdio.h>

int x = 1;
int main()
{
	int x = 0;
	printf("%d\n", x);
	return 0;
}

一个全局变量 x，一个局部变量 x，在打印时会优先搜索局部域，打印结果为 0

那如果我们想打印全局变量 x 呢？那就需要域作用限定符 :: 了

::的左边接作用域，如果空着什么都不写的话，默认是全局域。::的右边接作用域的变量或者函数等

如果想打印 全局变量x就接域作用限定符就可以了，::x

#include <stdio.h>

int x = 1;
int main()
{
	int x = 0;
	printf("局部变量x：%d\n", x);
	printf("全局变量x：%d\n", ::x);
	return 0;
}

image-20240117214257622

下面我们来看命名空间 namespace

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}
中即为命名空间的成员。成员可以是变量、函数和结构体等

命名空间限定了一个域，命名空间中的成员只作用于该命名空间

既然命名空间是一个域，那么命名空间也就可以配合域作用限定符使用

直接上代码

#include <stdio.h>

namespace ns1
{
	int x = 1;
}

namespace ns2
{
	int x = 2;
}
int main()
{
	printf("ns1-x：%d\n", ns1::x);
	printf("ns2-x：%d\n", ns2::x);
	return 0;
}

命名空间 ns1 中定义了变量 x，命名空间 ns2 中也定义了变量 x，两个变量 x 虽然同名，但并不会发生冲突，因为它们的作用域是自己的命名空间

image-20240123164401399

那如果命名空间重名了会怎样呢？编译器会将两个命名空间进行合并，如果两个重名的命名空间中有重名变量，那这两个变量就会冲突

命名空间重名，变量重名：

#include <stdio.h>

namespace ns1
{
	int x = 1;
}

namespace ns1
{
	int x = 2;
}
int main()
{
	printf("ns1-x：%d\n", ns1::x);
	printf("ns2-x：%d\n", ns1::x);
	return 0;
}

发生冲突：
image-20240117220257594

发生以上情况，要么给命名空间改名，不进行合并；要么将命名空间中的变量改名，防止命名冲突

了解到以上知识后，我们就可以解决最初的问题

#include <stdio.h>
#include <stdlib.h>

int rand = 1;
int main()
{
	printf("%d", rand);
	return 0;
}

image-20240117212324853

只需将变量rand放入命名空间中，在打印时使用域作用限定符

#include <stdio.h>
#include <stdlib.h>

namespace ns1
{
	int rand = 1;
}
int main()
{
	printf("%d\n", ns1::rand);
	printf("%p\n", rand);    // rand为函数名，是一个地址
	return 0;
}

image-20240117220626477

命名空间内成员的使用

现有命名空间如下：

namespace N
{
	int a = 10;
	char b = 'b';
}

想使用此命名空间中的成员有三种方式：

  1. 加命名空间和域作用限定符

    namespace N
{
	int a = 10;
	char b = 'b';
}

int main()
{
	printf("%d\n", N::a);
	printf("%c\n", N::b);
	return 0;
}

    这样可以精确访问命名空间内的成员，但是如果要大量使用某个成员，都要加命名空间和域作用限定符，就会有点繁琐

  2. 使用 using将命名空间内的某个成员引入

    #include <stdio.h>

namespace N
{
	int a = 10;
	char b = 'b';
}

using N::a;	// 将命名空间中的 a 引入

int main()
{
	printf("%d\n", a);	// 这里使用 using 引入了a，直接就能使用
	printf("%c\n", N::b);	// b没有使用 using 引用，所以使用时需要引用
	return 0;
}

  3. 使用 using namespace将整个命名空间引入

#include <stdio.h>

namespace N
{
	int a = 10;
	char b = 'b';
}

using namespace N;	// 将整个命名空间 N 引入

int main()
{
	printf("%d\n", a);	// 命名空间已经引入，其中的成员都可以直接使用
	printf("%c\n", b);
	return 0;
}

这里不要把引入命名空间和包含头文件搞混了。
文件中包含的头文件会在预处理阶段展开，就是将头文件代码拷贝到文件中
而引入命名空间是让编译器到指定命名空间进行搜索；不引入命名空间，编译器只会搜索局部域和全局域，不会去搜索特定命名空间

当我们使用 using namespace 命名空间展开时，如果代码较多，容易发生冲突的问题，因此这种方式只推荐在日常练习代码时使用，在编写大型项目时，建议使用前两种引用方式

C++的输入和输出

C++兼容C语言的输入输出方式，也有自己特有的输入输出

首先要引入头文件和命名空间

#include <iostream>
using namespace std;

std 是C++标准库的命名空间，里面存放着标准库的定义的实现

C++的头文件不带.h，一些旧的编译器（vc6.0）还支持 <iostream.h>

输出

使用 cout 标准输出对象（控制台）和流插入运算符 <<来进行输出

#include <iostream>
using namespace std;

int main()
{
	cout << "Hello World!" << endl;	// endl是特殊C++符号，表示换行输出
	return 0;
}

可以形象地记忆为 将要输出的内容顺着箭头插入到控制台

image-20240121184703068

输入

使用 cin标准输入对象（键盘）和流提取运算符 >>进行输入

#include <iostream>
using namespace std;

int main()
{
	int a = 0;

	cin >> a ;
	cout << "a:" << a << endl;

	return 0;
}

也可以像上面那样记忆，将键盘的内容顺着箭头放到目的地

image-20240121184806358

不难看出，使用cout和cin，与使用printf不同，不用我们指定格式，它们会自动识别变量类型

std命名空间的使用

std标准库的内容很多，日常使用时直接展开即可

如果进行项目编写时，不建议这样做，容易发生冲突

建议 std::cin 或者using std::cin

#include <iostream>
using std::cin;	// 只引入cin
int main()
{
	int a = 0;

	cin >> a ;
	std::cout << "a:" << a << std::endl;	// 引入 count 和 endl

	return 0;
}

缺省参数

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

void Func(int a = 0)	// 缺省值为0
{
	cout << a << endl;
}

int main()
{
	Func();	// 不传实参，形参为缺省值
	Func(10);	// 传实参，形参为实参的拷贝
}

image-20240121213712818

缺省参数的分类

全缺省参数

全缺省参数是指函数的参数全部缺省，调用函数时只要在函数参数限定个数之内，就可以传任意个参数
比如函数有3个参数，全部是缺省参数，那么调用此函数时可以传0、1、2、3个参数

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

int main()
{
	Func(1, 2, 3);
	Func(1, 2);
	Func(1);
	Func();
}

image-20240121214705273

半缺省参数

半缺省参数不是说函数的参数有一半是缺省，一半不是
半缺省参数是指函数的参数有一部分是缺省，一部分不是

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

int main()
{
	Func(1, 2, 3);
	Func(1, 2);
	Func(1);
}

image-20240121215217531

需要注意的是，半缺省参数必须从右向左给出，而且必须连续，不能间隔给

如果从左向右给出缺省

void Func(int a = 10, int b = 20, int c);

像上面这种，如果全部传实参还好，但是如果传的参数不足3个，最后一个参数（非缺省参数）就会少参数

间隔给缺省

void Func(int a, int b = 20, int c, int d = 40)

缺省参数不支持间隔跳着给参数，以上这种情况，必须得给 c 传参，那么就必须给a、b传参，但是这样 b 就是去作为半缺省的意义了

缺省参数的应用

当某个函数的某个参数不确定需要什么值，而我们又需要给出一个默认值时，就需要用到缺省参数

比如说顺序栈的初始化

typedef struct Stack
{
	int* data;
	int size;
	int capacity;
}Stack;

void StackInit(Stack* ps, int capacity = 4)
{
	ps->data = (int*)malloc(sizeof(int) * capacity);
	ps->capacity = capacity;
}

当我们明确知道栈要存多少数据时，就可以给capacity传参，如果不知道要存多少数据，就给缺省值

注意事项

  1. 半缺省参数必须从右往左给出，且必须连续

  2. 如果函数声明与定义分开了，那么缺省参数要放在函数声明中，缺省不能同时存在与声明与定义中

    关于这点，我们来详细看一下

    函数声明与定义分离，一般是模块化编程时才发生

    下面模拟编写栈时的情境

    Stack.h 这里存放的是函数声明

    #include <iostream>
using namespace std;

typedef struct Stack
{
	int* data;
	int size;
	int capacity;
}Stack;

void StackInit(Stack* ps, int capacity = 4);	// 缺省参数放在声明中

    Stack.cpp 这里存放的是函数定义

    #include "Stack.h"

void StackInit(Stack* ps, int capacity)		// 没有缺省
{
	ps->data = (int*)malloc(sizeof(int) * capacity);
	ps->capacity = capacity;
}

    test.cpp 这里用于测试函数

    #include "Stack.h"

int main()
{
	Stack st;
	StackInit(&st);
	return 0;
}

    我们先来验证缺省是否能同时存在于函数声明与定义中

    // Stack.h  函数声明
void StackInit(Stack* ps, int capacity = 4);	// 包含缺省

// Stack.cpp  函数定义
void StackInit(Stack* ps, int capacity = 4)		// 包含缺省
{
	ps->data = (int*)malloc(sizeof(int) * capacity);
	ps->capacity = capacity;
}

// test.cpp 测试
int main()
{
	Stack st;
	StackInit(&st);
	return 0;
}

    运行程序，发生报错

    image-20240122110910259

    这时我们再去掉声明中的缺省，保留定义中的缺省

    // Stack.h  函数声明
void StackInit(Stack* ps, int capacity);	// 去掉缺省

// Stack.cpp  函数定义
void StackInit(Stack* ps, int capacity = 4)		// 保留缺省
{
	ps->data = (int*)malloc(sizeof(int) * capacity);
	ps->capacity = capacity;
}

// test.cpp 测试
int main()
{
	Stack st;
	StackInit(&st);
	return 0;
}

    试运行，依然报错

    image-20240122111354616

    可以看到，错误发生在 test.cpp 中，虽然在函数定义中有缺省，但在函数声明中是没有缺省的，所以发生了如上错误

    这次我们使用正确方式运行，缺省放在函数声明中，函数定义中不放缺省

    // Stack.h  函数声明
void StackInit(Stack* ps, int capacity = 4);	// 缺省

// Stack.cpp  函数定义
void StackInit(Stack* ps, int capacity)		// 不缺省
{
	ps->data = (int*)malloc(sizeof(int) * capacity);
	ps->capacity = capacity;
}

// test.cpp 测试
int main()
{
	Stack st;
	StackInit(&st);
	return 0;
}

    运行正常，没有报错

    image-20240122112020611

    那为什么缺省参数要放在函数声明中呢？

    首先我们要知道，在程序的预处理阶段，会发生头文件展开、宏替换、条件编译、去注释等操作

    在上面的代码中，test.cpp 包含了头文件 Stack.h

    // Stack.h
#include <iostream>
using namespace std;

typedef struct Stack
{
	int* data;
	int size;
	int capacity;
}Stack;

void StackInit(Stack* ps, int capacity = 4);	// 缺省参数放在声明中

// test.cpp
#include "Stack.h"
int main()
{
	Stack st;
	StackInit(&st);
	return 0;
}

    在预处理阶段，头文件展开，就是将头文件的内容拷贝到 test.cpp 文件中

    // test.cpp
// ... 拷贝头文件的内容，上面的代码我就省略了，只展示函数声明
void StackInit(Stack* ps, int capacity = 4);	// 缺省参数放在声明中

int main()
{
	Stack st;
	StackInit(&st);
	return 0;
}

    预处理结束后，生成一个后缀为 .i 的新文件，内容类似上面的代码，之后会进入编译阶段。在编译阶段，会检查语法是否正确。

    如上文件中有函数的声明，函数声明中含有缺省参数，所以在调用时只传一个参数不存在语法错误

    如果在调用函数时使用缺省参数，而函数声明中没有缺省参数，定义中有缺省参数，在编译阶段会检测出语法错误，导致程序报错

  3. 缺省参数必须是常量或者全局变量

  4. C语言不支持（编译器不支持）

粗略地了解一下程序的翻译链接过程

过程：预处理、编译、汇编、链接

还是模拟编写栈的过程

Stack.h

#include <iostream>
using namespace std;

typedef struct Stack
{
	int* data;
	int size;
	int capacity;
}Stack;

void StackInit(Stack* ps, int capacity = 4);

Stack.cpp

#include "Stack.h"

void StackInit(Stack* ps, int capacity)
{
	ps->data = (int*)malloc(sizeof(int) * capacity);
	ps->capacity = capacity;
}

test.cpp

#include "Stack.h"

int main()
{
	Stack st;
	StackInit(&st);
	return 0;
}

预处理阶段要做的事情：展开头文件、宏替换、条件编译、去掉注释，最终生成的文件以.i结尾

image-20240122160238605

编译阶段：检查语法是否正确、生成汇编代码，生成的文件以.s结尾

image-20240122163920592

在编译阶段，代码转为汇编代码，此时我们就可以了解到函数调用的本质形式：call 函数地址

函数地址又是什么意思呢？这一点和数组有点像

数组由一堆元素组成，数组的地址是首元素的地址

函数由一堆指令组成，函数地址就是函数第一条指令的地址

调用函数实质就是跳转到函数的地址，依次向下执行函数中的指令

在vs中进入调试模式，再转到反汇编：

image-20240122161053896

进入反汇编，我们就可以看到函数调用的汇编形式了，call 函数地址

image-20240122162200314

image-20240122162736299

image-20240122162806615

当文件中没有函数定义，只有函数声明时，暂时是找不到函数的地址的，要到链接阶段寻找函数地址

也就是说，Stack.cpp中有函数的地址，test.cpp中没有函数的地址，函数调用暂时记为call StackInit(?)

汇编阶段，将汇编代码转为二进制机器码，生成的文件以.o结尾

image-20240122163941861

链接阶段：因为只有函数声明的文件找不到函数地址，所以在此阶段，就要凭借函数名去到其他文件中寻找函数地址。最后将各个文件合并到一起，形成可执行程序

image-20240122164445005

函数重载

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

我个人理解，函数重载相当于一词多义，一个函数可以有不同用法

函数重载要求：函数名相同，参数不同，即可构成函数重载

  1. 参数类型不同

    // 整数相加
int Add(int a, int b)
{
	cout << "int Add(int a, int b)" << endl;
	return a + b;
}

// 浮点数相加
double Add(double a, double b)
{
	cout << "double Add(double a, double b)" << endl;
	return a + b;
}

int main()
{
	Add(1, 2);
	Add(1.1, 2.2);
}

    image-20240122172615651

  2. 参数数量不同

    // 零参数
void f()
{
	cout << "f()" << endl;
}
// 1参数
void f(int a)
{
	cout << "f(int a)" << endl;
}
int main()
{
	f();
	f(1);
}

    image-20240122172915504

  3. 参数顺序不同（本质还是类型不同）

//参数顺序不同
void func(int a, char b)
{
	cout << "func(int a, char b)" << endl;
}

void func(char a, int b)
{
	cout << "func(char a, int b)" << endl;
}

image-20240122173904976

C++函数重载原理

为什么C语言不支持函数重载，而C++支持呢？

首先我们要知道，函数重载虽然函数名相同，但是函数地址不同

int Add(int a, int b);
double Add(double a, double b);
// 以上两函数的地址不同

image-20240123170124486

image-20240123170153499

之前我们已经了解过，在程序的翻译链接阶段，C语言是通过函数名来寻找函数地址的：call 函数名(函数地址)，C语言无法区分相同的函数名，那就找不到相应的函数地址，自然不支持函数重载

而C++支持函数重载，要寻找函数地址，就要区分相同的函数名。那C++是如何区分的呢？——名字修饰(name Mangling)

具体怎么修饰，不同编译器的修饰规则不同。下面我们以Linux下的g++为例，了解一下修饰规则是怎么样的。为什么不用Windows的vs？相对来说太复杂了，不如 g++通俗易懂

g++名字修饰规则：_Z+函数名长度+函数名+参数类型首字母

int Add(int a, int b);	// call _Z3Addii
double Add(double a, double b);	// call _Z3Adddd

下面我们就到Linux下进行验证

C语言编译器编译结果

现有test.c文件，内容如下

image-20240122181029641

image-20240122181133140

编译test.c文件，形成可执行文件testc

gcc -o testc test.c

image-20240122181323445

反编译testc

objdump -S testc

image-20240122181714483

可以看到，在Linux下，使用gcc完成编译后，函数名字的修饰没有发生改变

C++编译器编译结果

现有C++文件test.cc，文件内容不变

image-20240122182023078

image-20240122182040678

使用g++编译test.cc，得到testcpp

g++ -o testcpp test.cc

image-20240122182251481

接着进行反编译

objdump -S testcpp

image-20240122182356023

可以看到，在Linux下使用g++完成编译后，函数名字的修饰发生改变，编译器将函数的参数类型信息添加到修改后的名字中

阿洵Rain
关注
  • 20
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
C++从入门到进阶的系列书籍推荐
dvlinker的技术专栏
11-05 2万+
要多读书，读好书！一本书要多读几遍才好，每次都可能有新的收获！特别在是有一定的工作年限和工作经验之后！读书百遍，其义自见！ 下面就给大家推荐一下C++程序员进阶需要读的经典书籍： 1、C++入门书籍 C++是在C语言的基础上发展而来的，要学习C++之前需要先学习C语言。有了C语言基础之后再去学习C++。 1.1、C语言程序设计（谭浩强） 该书被公认为学习C语言程序设计的优秀教材，被全国大多数高校选用，是学习C语言的主流用书。本书比较通俗易懂，是初入者必备的书籍。 ........
C++基础入门.pdf
04-10
C++基础入门 C++是一种功能强大且灵活的编程语言，本文档旨在为读者提供一个基本的C++基础知识入门指南，包括创建项目、编写代码、运行程序、注释、变量、常量、关键字、标识符命名规则和数据类型等方面的知识点。 ...
C++基础入门（超详细）
qq_44859533的博客
07-02 5万+
全网很全的C++基础入门，针对每一个概念以及概念之后的代码实现运行结果。可以帮助新手很快上手，也可以帮助老手回顾C++。
C++教程从入门到实战
believer
08-09 13万+
C++基础教程 一、数据类型 1.1、第一个C++程序 1.2、数据类型 1.3、常量及符号 1、整型常量：整型常量可以分为有符号整型常量和无符号整型常量 八进制：以0开头，即以0作为八进制数的前缀，每位取值范围是0~7，八进制数通常是无符号数。 例如：016、0101、0128都是合法的八进制数 十六进制：以0x或者0X开头，其数码取值范围0 ~ 9，以及A ~ F或者a ~ f 例如：0X2A1、0XC5、0XFFFF都是合法的16进制数 2、实型常量 小数表示法：由整
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 25万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++入门基础（万字详解！！！）
忘忧.
08-15 3万+
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
C++基础入门
a577715979的博客
01-02 5029
C++入门
C++ STL详解超全总结(快速入门STL)
行码棋
02-24 13万+
C++STL合集，包含vector，stack，queue，map，set，array，tuple，deque，priority_queue等诸多内容，全文上万字。
C++编程入门
博客
04-15 4152
C++编程入门
c++介绍与入门基础（详细总结）
includeevey的博客
09-18 9650
该文章讲述c++的背景和基本知识。若认真看完就是对我最大的肯定。
c++ vector用法 入门必看 超详细
weixin_52115456的博客
07-29 6万+
vector容器名如储存int型的值vectorv;储存double型的值vectorv;储存string型的值vectorv;储存结构体或者类的值的值vectorv;当然也可以定义vector数组储存int型的值vectorv[n];储存double型的值vectorv[n];等等，n为数组的大小。...
C++20 实践入门，第六版，英文
12-14
C++20 实践入门指南 C++是一种功能强大且灵活的编程语言，广泛应用于操作系统、游戏、数据库、Web开发等领域。本书《C++20 实践入门》第六版，英文版，旨在帮助读者从初学者到专业开发者的逐步学习之旅。 C++ 语言...
c++初学入门
02-06
c++语言入门基础知识,共计12个课题,第一课题：c++语言的基本框架 第二课题：c++语言的基本数据类型表达式 第三课题：c++语言的基本语句及顺序结构的程序设计 第四课题：c++语言的控制结构选择结构的程序设计 第五...
C++基础入门.md
11-21
C++基础入门.md、C++基础入门.md、C++基础入门.md 一提到这个名字相信有需要的小伙伴瞬间就能明白了，打开的话用typora这个软件，特别好，不认识名字的朋友也不要紧 这就是一个C++编程文档，很实用的，里边有一些C++...
C++游戏编程入门(第4版)
01-05
非常适合初学C++的新手阅读，书中讲C++基本语法与游戏开发实例相结合，不枯燥，本人整理了书签方便阅读
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1024
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
c++ 6.11
Johan1111的博客
06-11 270
(5)另外， RMB 类还包含一个静态整型成员变量 count，用于记录当前已创建的 RMB 对象的数量。每当创建一个新的 RMB 对象时，count 应该自增 1；(1)重载算术运算符 + 和 -，使得可以对两个 RMB 对象进行加法和减法运算，并返回一个新的 RMB 对象作为结果。(2)重载关系运算符 >，判断一个 RMB 对象是否大于另一个 RMB 对象，并返回 true 或 false。(3)重载前置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1。
【C++提高编程-05】----C++之Deque容器实战
一伦明悦的博客
06-15 804
Deque（双端队列）是C++ STL中的一种序列容器
C语言猜输赢游戏
最新发布
qq_69383179的博客
06-15 1407
这里有关于C语言猜输赢游戏的程序
c++ cuda编程入门
08-18
CUDA C/C++是CUDA编程的主要语言，可以在Windows系统下使用Visual Studio等开发环境进行编程。想要入门CUDA编程，可以参考NVIDIA官方提供的文档和教程，如《Professional CUDA® C Programming》一书中有详细介绍。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿洵Rain

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值