C++随笔-1

已于 2024-03-27 23:56:38 修改
阅读量328 收藏
点赞数
分类专栏： C/C++ 文章标签： c++
于 2022-03-05 17:49:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TimerSea/article/details/123298335
版权

main 函数

#include <isotream>     // 定义了输入、输出流等

int main(int argc, char *argv[]) {    // main 函数
    std::cout << "HelloWorld" << std::endl;
    return 0;
}
  • main 函数作为程序执行入口函数，只能有一个main函数
  • 特别注意c++对字符大小写敏感，全部用英文字符
  • 使用标准库需要添加对应标准库的头文件
  • int <函数返回值类型，返回有符号整形值>
  • main(int argc, char *argv[]) 函数名：main，括号中为传入函数的形式参数
  • std:: c++标准库的命名空间
  • cout 标准库提供的输出流，endl 为输出控制符
  • << 输出流重定向运算符
  • “HelloWorld” 输出内容
  • c++语句都是以 ; 结尾，自动忽略空格

语句注释

void Annotaion() {
    // 打印 #
    std::cout << "#####" << std::endl;
    /*
    std::cout << "#####" << std::endl;
    这条语句打印 #
    */
}
  • c++注释分单行注释和多行注释
  • 单行注释：// 单行注释符号
  • 多行注释：/**/ 多行注释符号

头文件

#include <isotream>  // 头文件

int main() {
	std::cout << "HelloWorld" << std::endl;
    return 0; 
}
  • c++在程序编译之前使用预处理器处理源文件
  • 预处理器处理以 #include 形式的编译指令， 编译时会自动运行
  • 例如 #include, 预处理器将 iostream 文件内容替换或添加到源文件中
  • 实际源文件没有被修改，两者会复合成可供编译的复合文件
  • c++旧式头文件引用 #include <iostream.h>
  • c旧式头文件引用 #include <stdio.h>
  • c++新式头文件引用 #include
  • c++中对c头文件引用 #include
  • c++中对c头文件引用 #include <stdio.h>，两者均可，推荐形式

命名空间

namespace demo {   // 命名空间
    void Namespace() {
        std::cout << "#####" << std::endl;
    }
}
  • 命名空间尽可能避免不同开发厂商间程序源文件中函数、变量等命名产生冲突
  • 声名方法 namespace demo { // 程序代码 }
  • 调用方式1 using namespace std;
  • 调用方式2 using namespace std::cout
  • 调用方式3 std::cout << std::endl;
  • c++命名空间的名字一般小写，标准库命名空间为 std
  • 如上例子调用方式 demo::Namespace();

变量命名规则

void VariableName() {
	int name;    // valid
	int Name;    // valid
    int name_;   // valid
    int name1;   // valid
    int name_1;  // valid
    int _name;   // valid
	int 1name;   // invalid
	int 1_;      // invalid
}
  • 变量声明语法： 变量类型(如 int) 变量名
  • 只能使用字母字符、数字和下划线(_)
  • 数字不能作为变量的第一个字符出现
  • c++对大小写严格区分
  • 不能将c++所使用的关键字作为变量名称
  • 对名称长度没限制，但尽量做到见名知其意
  • 常见命名风格：全小写，中间以下划线分割(name_this_var)、小驼峰(nameThisVar)、大驼峰(NameThisVar)

变量定义方式

void DefineVariable() {
    int a;
    a = 10;
    int b = 10;
}
  • 两种方式：先声明后初始化(赋值)，声明的同时初始化
  • c++变量使用必须先声明在使用，否则编译器会报错

变量初始化

int Init() {
	int a = 10;
	int b;
	b = 10;
	int c = INT_MAX;
	int d = c;
	int e(10);
	int f{10};
	int g = {10};
}
  • 声明变量的同时初始化
  • 先声明后初始化
  • 字面常量值初始化
  • 一个变量初始化另一个变量(类型不匹配可能发生隐式数据类型转换)
  • c++新增变量初始化语法，声明后直接后边跟小括号、大括号(c++11)初始化方式
  • 如果不对函数内部定义的变量初始化(局部变量)，该变量的值是不确定的

climits中的符号常量

符号常量表示
CHAR_BITchar的位数
CHAR_MAXchar的最大值
CHAR_MINchar的最小值
SCHAR_MAXsigned char的最大值
SCHAR_MINsigned char的最小值
UCHAR_MAXunsigned char的最大值
SHRT_MAXshort的最大值
SHRT_MINshort的最小值
USHRT_MAXunsigned short的最大值
INT_MAXint的最大值
INT_MINint的最小值
UINT_MAXunsigned int的最大值
LONG_MAXlong的最大值
LONG_MINlong的最小值
ULONG_MAXunsigned long的最大值
LLONG_MAXlong long的最大值
LLONG_MINlong long的最小值
ULLONG_MAXunsigned long long的最大值

有符号整型

#include <iostream>
#include <climits>       // 定义了符号常量

void IntegerType() {
    short a = SHRT_MAX;  // SHRT_MIN
    int b = INT_MAX;     // INT_MIN
    long c = LONG_MAX;   // LONG_MIN
    long long d = LONG_LONG_MAX;  // LONG_LONG_MIN

    std::cout << "short : " << a << std::endl;
    std::cout << "int : " << b << std::endl;
    std::cout << "long : " << c << std::endl;
    std::cout << "long long : " << d << std::endl;

    std::cout << "sizeof short : " << sizeof(short) << " byte" << std::endl;
    std::cout << "sizeof int : " << sizeof(int) << " byte" << std::endl;
    std::cout << "sizeof long : " << sizeof(long) << " byte" << std::endl;
    std::cout << "sizeof long long : " << sizeof(long long) << " byte" << std::endl;
}

输出结果：
short : 32767
int : 2147483647
long : 2147483647
long long : 9223372036854775807
sizeof short : 2 byte
sizeof int : 4 byte
sizeof long : 4 byte
sizeof long long : 8 byte

  • 整形就是没有小数部分的数字，不同类型使用不同的位来存储
  • 包括short、int、long、long long，不同类型有不同的存储长度，c++提供了一种灵活的标准
  • short至少16位
  • int至少和short一样长
  • long至少32位，且至少与int一样长
  • long long至少64位，且至少与long一样长
  • 1GB = 1024MB，1MB = 1024KB，1KB = 1024byte，1byte = 8bit
  • 如上例子中获取了这几种类型的长度和最值，实际执行使用平台不同可能会存在差异
  • sizeof运算符可得出变量或类型的长度，其中使用变量时，其后边的括号可选，例如(sizeof a;)或(sizeof (a)😉
  • 头文件 climits 中定义了类型的长度范围

无符号整型

#include <iostream>
#include <climits>    

void UnsignedType() {
    unsigned short a = USHRT_MAX;  
    unsigned int b = UINT_MAX;    
    unsigned long c = ULONG_MAX;   
    unsigned long long d = ULONG_LONG_MAX; 
    unsigned e = UINT_MAX;     // unsigned int
    
    std::cout << "unsigned short : " << a << std::endl;
    std::cout << "unsigned int : " << b << std::endl;
    std::cout << "unsigned long : " << c << std::endl;
    std::cout << "unsigned long long : " << d << std::endl;
    std::cout << "unsigned int : " << e << std::endl;
    
    std::cout << "sizeof unsigned short : " << sizeof(unsigned short) << " byte" << std::endl;
    std::cout << "sizeof unsigned int : " << sizeof(unsigned int) << " byte" << std::endl;
    std::cout << "sizeof unsigned long : " << sizeof(unsigned long) << " byte" << std::endl;
    std::cout << "sizeof unsigned long long : " << sizeof(unsigned long long) << " byte" << std::endl;
    std::cout << "sizeof unsigned int : " << sizeof(unsigned) << " byte" << std::endl;
}

输出结果：
unsigned short : 65535
unsigned int : 4294967295
unsigned long : 4294967295
unsigned long long : 18446744073709551615
unsigned int : 4294967295
sizeof unsigned short : 2 byte
sizeof unsigned int : 4 byte
sizeof unsigned long : 4 byte
sizeof unsigned long long : 8 byte
sizeof unsigned int : 4 byte

  • 无符号整型最小值为0，使用 unsigned 关键字修饰类型
  • 包括unsigned short、unsigned int、unsigned long、unsigned long long
  • 最大值可根据宏定义查看

整型变量溢出

void MaxMin() {
    short a = SHRT_MAX;
    short b = SHRT_MIN;
    int c = INT_MAX;
    int d = INT_MIN;
    // ...
    std::cout << "short max: " << a << " short min: " << b << std::endl;
    std::cout << "short max + 1: " << a + 1 << " short min - 1: " << b - 1 << std::endl;
    std::cout << "int max: " << c << " int min: " << d << std::endl;
    std::cout << "int max + 1: " << c << " int min - 1: " << d << std::endl;

    unsigned long e = ULONG_MAX;
    std::cout << "unsigned long max: " << e << " unsigned long min: 0 " << std::endl;
    std::cout << "unsigned long max + 1: " << e + 1 << " unsigned long min - 1:" << e + 1 - 1 << std::endl;
}

输出结果：
short max: 32767 short min: -32768
short max + 1: 32768 short min - 1: -32769
int max: 2147483647 int min: -2147483648
int max + 1: 2147483647 int min - 1: -2147483648
unsigned long max: 4294967295 unsigned long min: 0
unsigned long max + 1: 0 unsigned long min - 1:4294967295

  • 每种类型都有其对应的最值范围，使用时合理选择变量类型切勿超过最值范围
  • 如上例子分析可见，最大值溢出后会变成最小值、最小值溢出后会变成最大值

整型字面值

void HexOctDec() {
    int a = 15656;
    std::cout << "Hex: " << std::hex << a << std::endl;
    std::cout << "Oct: " << std::oct << a << std::endl;
    std::cout << "Dec: " << std::dec << a << std::endl;
}

输出结果：
Hex: 3d28
Oct: 36450
Dec: 15656

  • 整型字面值是显式书写的常量，c++支持以八进制、十进制、十六进制
  • 使用 std::cout 输出默认为十进制，输出八进制或十六进制需要添加控制符号
  • 十六进制以0x或0X标识，例如 int a = 0x96;，使用字符0、1、2、3、4、5、6、7、8、9、A、B、C、D、E、F
  • 八进制以0标识，例如 int a = 071;，使用字符0、1、2、3、4、5、6、7

c++确定常量类型

void ConstVarType() {
    auto a = 1942;
    std::cout << "int: " << (typeid (a) == typeid (int))  << std::endl;
    auto b = 1942U;
    std::cout << "unsigned int: " << (typeid (b) == typeid (unsigned int))  << std::endl;
    auto c = 1942L;
    std::cout << "long: " << (typeid (c) == typeid (long))  << std::endl;
    auto d = 1942UL;
    std::cout << "unsigned long: " << (typeid (d) == typeid (unsigned long))  << std::endl;
    auto e = 1942LL;
    std::cout << "long long: " << (typeid (e) == typeid (long long))  << std::endl;
    auto f = 1942ULL;
    std::cout << "unsigned long long: " << (typeid (f) == typeid (unsigned long long))  << std::endl;
    auto g = static_cast<short>(1942);
    std::cout << "short: " << (typeid (g) == typeid (short))  << std::endl;
    auto h = static_cast<unsigned short>(1942);
    std::cout << "unsigned short: " << (typeid (h) == typeid (unsigned short))  << std::endl;
    auto i = 1942.0;
    std::cout << "double: " << (typeid (i) == typeid (double))  << std::endl;
    auto j = 1942.0f;
    std::cout << "float: " << (typeid (j) == typeid (float))  << std::endl;
}

输出结果：
int: 1
unsigned int: 1
long: 1
unsigned long: 1
long long: 1
unsigned long long: 1
short: 1
unsigned short: 1
double: 1
float: 1

  • 整型常量默认为 int(不溢出时)、浮点型常量默认为 double
  • 指定常量类型可使用后缀声明
  • 如上例子通过不同后缀常量创建不同类型的变量，最终判断创建的变量类型是否为指定的变量类型，输出1表示两边相同
  • typeid 运算符用来获取一个表达式的类型信息
  • auto在c++11中可用作变量的类型自动推导

char类型

void CharType() {
    std::cout <<"char max: " << CHAR_MAX << " char min: " << CHAR_MIN << std::endl;
    std::cout <<"unsigned char max: " << UCHAR_MAX << " unsigned char min: " << 0 << std::endl;

    char a = 'H';
    char b = 'e';
    char c = 'l';
    char d  ='l';
    char e = 'o';
    std::cout << a << b << c << d << e << std::endl;

    char f = 56;
    std::cout << "f : " << f << std::endl;
    std::cout << "f : " << static_cast<int>(f) << std::endl;

    char g;
    std::cout << "please input a character: ";
    std::cin >> g;       // 等待从终端输入字符赋值给变量g
    std::cout << "print character: ";
    std::cout.put(g);    // 打印一个字符
    std::cout << std::endl;
}

输出结果：
char max: 127 char min: -128
unsigned char max: 255 unsigned char min: 0
Hello
f : 8
f : 56
please input a character: H
print character: H

  • char类型是专为存储字符(如字母和数字)而设计的，最值范围也比较小
  • 使用std::cout输出字符会输出对应的ASCII字符集，想输出数字需要强制转换为整型
  • static_cast是c++提供的运算符，把一个表达式转换为某种类型，但没有运行时类型检查来保证转换的安全性
  • wchar_t(宽字符类型)、c++11新增char16_t和char32_t类型
字符名称ASCII符号c++代码十进制ASCII码十六进制ASCII码
换行符NL(LF)\n100XA
水平制表符HT\t90X9
垂直制表符VT\v110XB
退格BS\b80X8
回车CR\r130XD
振铃BEL\a70X7
反斜杠|\|920X5C
问号??630X3F
单引号’’390X27
双引号""340X22

bool类型

void BoolType() {
    bool a = true;
    bool b = false;
    bool c = 10;
    bool d = 0;
    int e = 10;
    bool f = e;
    int g = f;
    std::cout << "a : " << a << std::endl;
    std::cout << "b : " << b << std::endl;
    std::cout << "c : " << c << std::endl;
    std::cout << "d : " << d << std::endl;
    std::cout << "e : " << e << std::endl;
    std::cout << "f : " << f << std::endl;
    std::cout << "g : " << g << std::endl;
}

输出结果：
a : 1
b : 0
c : 1
d : 0
e : 10
f : 1
g : 1

  • 布尔变量的值只有 true、false
  • 字面值true和false都可以被转换为int类型，true是1，false是0
  • 任何数字值或指针值都可以被转换(不用强制显示转换)为bool值，非零值为true，零值为false

浮点类型

void FloatType() {
    float a = 1.0;
    double b = 1E-4;
    long double c = 1.0;
    std::cout << "a: " << a << "\tb: " << b << "\tc: " << c << std::endl;

    std::cout << "sizeof float: " << sizeof (float) << std::endl;
    std::cout << "sizeof double: " << sizeof (double) << std::endl;
    std::cout << "sizeof long double: " << sizeof (long double) << std::endl;

    std::cout << "double max: " << __DBL_MAX__ << "\tdouble min: " << __DBL_MIN__ << std::endl;
}

输出结果：
a: 1 b: 0.0001 c: 1
sizeof float: 4
sizeof double: 8
sizeof long double: 16
double max: 1.79769e+308 double min: 2.22507e-308

  • 浮点数能够表示带小数部分的数字
  • 三种类型定义，float、double和long double，小数精确度依次提高
  • 可以使用科学计数法初始化
  • 浮点数可以表示整数
  • 通常浮点数具有精度损失，运算速度相对整数慢

类型转换

void ConvertType() {
    int a = 10;
    long long b = a;
    double c = 4.5;
    int d = c;
    int *e = &a;
    long *f = reinterpret_cast<long *>(e); // 强制类型转换
    std::cout << "a: " << a << std::endl;
    std::cout << "b: " << b << std::endl;
    std::cout << "c: " << c << std::endl;
    std::cout << "d: " << d << std::endl;
    std::cout << "*e: " << *e << std::endl;
    std::cout << "*f: " << *f << std::endl;
}

输出结果：
a: 10
b: 10
c: 4.5
d: 4
*e: 10
*f: 10

  • 两种转换方式：隐式转换和显式转换(强制类型转换)
  • 隐式转换：将长度小的类型赋值给长度大的类型时会隐式转换为长度大的类型
  • 显式转换：将类型强制转换并赋值给某种类型
  • 浮点数直接赋值给整型将丢失小数部分
  • 尽量避免设计的程序中使用显式类型转换
  • C++引入了四种功能不同的强制类型转换运算符：static_cast、reinterpret_cast、const_cast 和 dynamic_cast
  • static_cast 用于进行比较低风险的转换，如整型和浮点型、字符型之间的互相转换，如果对象所属的类重载了强制类型转换运算符T(如 T 是 int、int* 或其他类型名)，则 static_cast 也能用来进行对象到 T 类型的转换，static_cast 不能用于在不同类型的指针之间互相转换，也不能用于整型和指针之间的互相转换，当然也不能用于不同类型的引用之间的转换，因为这些属于风险比较高的转换
  • reinterpret_cast 用于进行各种不同类型的指针之间、不同类型的引用之间以及指针和能容纳指针的整数类型之间的转换，转换时，执行的是逐个比特复制的操作，这种转换提供了很强的灵活性，但转换的安全性只能由程序员的细心来保证了，例如，程序员执意要把一个 int* 指针、函数指针或其他类型的指针转换成 string* 类型的指针也是可以的
  • const_cast 运算符仅用于进行去除 const 属性的转换，它也是四个强制类型转换运算符中唯一能够去除 const 属性的运算符，将 const 引用转换为同类型的非 const 引用，将 const 指针转换为同类型的非 const 指针时可以使用 const_cast 运算符。
  • 用 reinterpret_cast 可以将多态基类(包含虚函数的基类)的指针强制转换为派生类的指针，但是这种转换不检查安全性，即不检查转换后的指针是否确实指向一个派生类对象，dynamic_cast专门用于将多态基类的指针或引用强制转换为派生类的指针或引用，而且能够检查转换的安全性，对于不安全的指针转换，转换结果返回 NULL 指针，dynamic_cast 是通过 运行时类型检查 来保证安全性的，dynamic_cast 不能用于将非多态基类的指针或引用强制转换为派生类的指针或引用——这种转换没法保证安全性，用 reinterpret_cast

数组

void ArrayType() { // 一维数组
    int arr[10];   //  声明数组未初始化，值是随机值
    for (int i = 0; i < 10; ++i)  // 循环打印数组元素
        std::cout << arr[i] << "   ";
    std::cout << std::endl;
    
    arr[0] = 10;  // 局部元素赋值，索引访问数组元素
    arr[2] = 20;
    for (int i = 0; i < 10; ++i)  // 循环打印数组元素
        std::cout << arr[i] << "   ";
    std::cout << std::endl;
    
    for (int i = 0; i < 10; ++i)  // 数组每个元素赋值
        arr[i] = i;
    
    for (int i = 0; i < 10; ++i)  // 循环打印数组元素
        std::cout << arr[i] << "   ";
    std::cout << std::endl;
    
    int *p = arr;  // 指针指向数组，数组名就是数组的首地址指针
    for (int i = 0; i < 10; ++i)  // 循环打印数组元素
        std::cout << p[i] << "   ";
    std::cout << std::endl;
    
    // 数组初始化方式
    int a[4] = {1};      // 初始化第一个元素，其余元素默认为 0
    for (int i = 0; i < 4; ++i)  // 循环打印数组元素
        std::cout << a[i] << "   ";
    std::cout << std::endl;
    
    int b[2] = {1, 2};   // 初始化所有元素
    for (int i = 0; i < 2; ++i)  // 循环打印数组元素
        std::cout << b[i] << "   ";
    std::cout << std::endl;
    
    int c[] = {1, 2, 3}; // 全部元素初始化并自动推导数组元素个数
    for (int i = 0; i < 3; ++i)  // 循环打印数组元素
        std::cout << c[i] << "   ";
    std::cout << std::endl;
    
    int d[2]{0, 2};      // c++11的初始化列表
    for (int i = 0; i < 2; ++i)  // 循环打印数组元素
        std::cout << d[i] << "   ";
    std::cout << std::endl;
    
    int e[10] = {};      // 所有元素初始化为零
    for (int i = 0; i < 10; ++i)  // 循环打印数组元素
        std::cout << e[i] << "   ";
    std::cout << std::endl;
    
    int f[10]{};         // 所有元素初始化为零
    for (int i = 0; i < 10; ++i)  // 循环打印数组元素
        std::cout << f[i] << "   ";
    std::cout << std::endl;
}

输出结果：
6684064 0 14755456 0 6684240 0 16 0 8 0
10 0 20 0 6684240 0 16 0 8 0
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
1 0 0 0
1 2
1 2 3
0 2
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0

  • 数组是一种数据格式，存储多个相同类型的值
  • 声明：值类型、数组名和数组中的元素个数(type arr[size])
  • 数组访问可通过下标索引访问(arr[i])或指向数组的指针访问
  • 数组可容纳的元素数量一旦确定就不能改变，访问数组中的元素时一定要注意索引是否越界(超出数组长度)
  • c++中索引都以 0 开始，即数组中的第一个元素为 arr[0]
  • 一维数组初始化方式如上例子
无夜_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++的一些随笔
01-28
一些随手笔记关于c++
c++随笔-删除文件
CSDN_Anonymous的博客
06-07 4609
c++删除文件非常简单，只需remove("文件名")即可。 需要包含#include<windows.h>头文件。 一般情况下，remove
c++随笔-4
TimerSea的博客
03-10 894
本文介绍c++中define、typedef、const、引用、函数等相关知识
C++随笔-野指针
qq_34202054的博客
02-23 501
野指针 指向”垃圾“内存的指针可称为野指针。 指针变量没有初始化。 int* a; *a = 123; 编译结果： 已经不用的指针变量没有置为NULL。 指针的操作超出了变量的作用范围。
c++随笔-7
TimerSea的博客
03-15 660
本文介绍c++中函数模板、类模板、异常、文件操作等相关知识
C++随笔-数据类型
qq_34202054的博客
02-14 288
名称 字节 范围 char 1 有符号(signed):-128到127；无符号(unsigned):0到255 short int(short) 2 有符号(signed):-32768到32767；无符号(unsigned):0到65535 long int(long) 4 有符号(signed):-2,147,483,647 到 2,147,483,647；无符号(unsigned):0到4,294,967,295 int 4 有符号(signed):–2147483648...
c++计算eigen随笔(8)-数组、矩阵、向量（1）
01-20
typedef Matrix MyMatrixType; typedef Array MyArrayType; Scalar是系数的标量类型(例如，float、double、bool、int等)。 RowsAtCompileTime和ColsAtCompileTime是矩阵在编译时或动态状态下的行数和列数。...
c++计算eigen随笔(10)-数组、矩阵、向量（3）
01-06
默认构造函数总是可用的，从不执行任何动态内存分配，也从不初始化矩阵系数 Matrix3f a; MatrixXf b; 在这里, a是一个3×3矩阵，带有一个未初始化系数的普通浮点]数组， b是一个动态大小的矩阵，它当前的大小是0乘0...
C++ Primer 中文版（第 5 版）第一章——随笔（含练习）-源码
04-10
源码
C++生成dump文件
03-22
C++ windows工程中 简单生成 dump文件，以便问题定位
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 254
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 903
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 261
C语言如何在链表中的指定位置插⼊结点？
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 405
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ STL标准库解析｜实现string类的迭代器string::iterator
糖炒栗子
05-17 933
的迭代器标识这样我们也可以遍历到底层的最后一个元素。循环过程中做了++it，说明我们当前迭代器要跳到下一个迭代器来完成遍历，至于它底层到底是数组、链表还是哈希表无论是什么我们都不用管，我们作为使用者只需要对迭代器进行++即可。底层数据结构如何到下一个元素的具体操作都封装在了我们迭代器的++操作中，用户作为使用者是无感的（这就是所谓的透明地访问容器内部元素的值）。最后打印使用迭代器进行解引用。
C++ 练习题四道 hv-LDM
m0_73379721的博客
05-14 358
4.文件操作 查找指定字符。1.判断两个日期间的天数。
C++ 复习 -- 构造和析构
mx_jun的博客
05-14 889
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。构造的是什么呢？构造成员变量的初始化值，内存空间等构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
cjson 创建layui 目录树
ww506772362的专栏
05-14 560
#include "sys_inc.h" #include "cJSON.h"#include <stdio.h> #include <stdlib.h> #include <string.h> #include "cJSON.h"typedef struct UAXCatalog UAXCatalog_t; struct UAXCatalog { uint32_t parental; char name[64]; //设备名称和别名 char
C++——引用
fax_player的博客
05-17 907
本篇文章主要讲述在C++中关于引用的一些概念及其用法，还有引用与指针的些许区别，希望能够帮助大家理解~
download c++ 2015-2019 redistributable
05-13
C++ 2015-2019可重发行组件是一款由微软公司提供的基于C++的软件开发包。当用户在计算机中运行需要使用到C++的应用程序或游戏时，需要下载和安装此软件以确保应用程序或游戏能够正常运行。同时，用户还可以通过安装...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值