C++基础

参考：C++ 教程 | 菜鸟教程 (runoob.com)

用于部署、opencv

学习内容：编程核心部分

学习要求：能读懂代码，复现代码

python：语言简洁，用于解决数据分析问题

面向对象：一种程序的编程思维，设计程序的基础逻辑

面向对象的三大特点：封装、继承、多态

编译文件

cmake_minimum_required(VERSION 3.28)
project(test20240428)

set(CMAKE_CXX_STANDARD 17)

add_executable(test20240428 main.cpp)

cmake_minimum_required：指定编译器最低要求版本

add_executable：添加可执行程序入口

入口/接口

封装：划分功能，避免不同功能之间相互干扰

入口/接口留一个：便于管理功能

python没有封装，用main来限制入口

C++这样的静态语言，有主函数main()

主函数main()

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

如果程序不放在主函数里，代码不会被执行

每行代码以分号结尾

return作用：1. 返回一个值 2. 结束当前的函数

#include调用头文件

std::cout表示函数输出

main函数中如果不写return 0，不会报错，也能正常执行程序。因为c++的main函数默认会return 0，程序是由CPU的核中的进程执行，为了避免程序出错，建议写上return 0.

注释

单行注释：双斜杠

多行注释：/*开头，*/结尾

// 单行注释

/*
 * 多行注释
 */

中文乱码问题

参考：clion：输出中文乱码终极解决方案

变量

容器，表示一块内存空间，用于存放数据

要使用变量前，必须先声明变量，并赋值

新建c++文件

c++ class：c++的类（会同时创建源代码和头文件）

c++ source：c++源代码

c++ header：c++头文件

标识符

标识符用于变量、函数、类、模块命名

由数字、大小写字母、下划线、美元符号组成，不允许数字开头

作用域

局部变量：函数或代码块内部声明的变量

全局变量：程序外声明的变量，可被任何函数访问

常量

固定值，程序执行期间不会被改变，又称字面量

常量可是任何基本数据类型

定义常量方式：1. #define 2. 限定符const

#define ZERO 0
const float pi = 3.141592653;

基本数据类型

字符型：单引号括起来的内容，仅赋一个字符，编写多个字符，会赋值最后一个字符

多个字符用字符串存储，使用双引号括起来，需要引入string头文件

#include <iostream>
#include <string>
#define ZERO 0
const float pi = 3.141592653;


int main() {
    int a;
    a = 3;
    std::string s = "abc";
    std::cout<< s << std::endl;
    return 0;
}

常用数字类型

short（2字节）、int（4字节）、long（4字节）、long long（8字节）、float（4字节）、doule（8字节）

1字节为8位

double输出浮点数只输出6位，6位后的会自动四舍五入

python中

• float16：半精度

• float32：单精度

• float64：双精度

C++中

• float：单精度
• double：双精度

#include <iostream>


int main() {
    int a;
    a = 3;
    double d = 309419.6123456;
    double d2 = 3094.4123456;
    std::cout<< d << std::endl;
    // 309420
    std::cout<< d2 << std::endl;
    // 3094.41
    return 0;
}

数组

声明一个数组，需要指定元素的类型和元素的数量

type arrayName [ arraySize ];

声明数组

    double arr_num[3];
    arr_num[2] = 3;
    std::cout<< arr_num[0] << std::endl;
    // 6.95137e-310
    std::cout<< arr_num[2] << std::endl;
    // 3

    double arr_num2[] = {1.0, 2.0, 34.6, 56.3, 12};
    std::cout<< arr_num2[0] << std::endl;
    // 1
    std::cout<< arr_num2[2] << std::endl;
    // 34.6

凡是进行了赋值运算符，C++就会创建新的对象

    string str1;
    string str2 = "good";
    string str3 = "hello";

    str1 = str3;
    cout << str1 << endl;
    // hello
    cout << str2 << endl;
    // good
    cout << str3 << endl;
    // hello

    str3 += "c++";
    cout << str1 << endl;
    // hello
    cout << str2 << endl;
    // good
    cout << str3 << endl;
    // helloc++

    str3 += "123";
    cout << str3 << endl;
    // helloc++123

    str3 += char(65);
    cout << str3 << endl;
    // helloc++123A

运算符

赋值运算符

=

赋值符左边是变量，右边是值

    int num;
    num = 3;
    cout << num << endl;
    // 3
    num = {2};
    cout << num << endl;
    // 2
    num = 'a';
    cout << num << endl;
    // 97
    num = {'A'};
    cout << num << endl;
    // 65

    int x, y;
    x = y = 20;
    cout << x << endl;
    // 20
    cout << y << endl;
    // 20

算数运算符

+，-，*，/，%，++，–

++：自增运算符，运算后，数值加1

–：自减运算符，运算后，数值减1

    int x, y;
    x = y = 20;
    int m = x++;
    cout << m << endl;
    // 20
    cout << x << endl;
    // 21
    int n = --y;
    cout << n << endl;
    // 19
    cout << y << endl;
    // 19

关系运算符

==，!=，>，<，>=，<=

>=表示>或=

int m = 20;
int n = 19;
cout << (m == n) << endl;
// 0
cout << (m != n) << endl;
// 1
cout << (m >= n) << endl;
// 1
cout << (m > n) << endl;
// 1
cout << (m <= n) << endl;
// 0
cout << (m < n) << endl;
// 0

逻辑运算符

与（&&）、或（||）、非（!）

连接两个关系表达式

cout << (1 && 1) << endl;
// 1
cout << (1 || 1) << endl;
// 1
cout << (0 || 1) << endl;
// 1
cout << (!0) << endl;
// 1

位运算符

&、|、^、~、<<、>>

位运算本质：十进制数值转为二进制，然后在二进制上对应位作逻辑运算

<<：二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）

>>：二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

int m = 2;
int n = 3;
cout << (m & n) << endl;
// 2
cout << (m | n) << endl;
// 3
cout << (m ^ n) << endl;
// 1
cout << (m << 2) << endl;
// 8
cout << (m >> 2) << endl;
// 0

条件运算符

三元运算符

语法：表达式 ? 值为真赋的值 : 值为假赋的值

类型转换

不同类型之间的数据，需要可以相互转换才能一起计算

隐式类型转换

算术运算过程，自动转换数据类型

高精度转为低精度数据类型，可能会丢失精度

强制类型转换

强制转换两种方式：1. 函数 2. 强转运算符static_cast

    cout << (double(8) / 5) << endl;
    // 1.6
    cout << (static_cast<double >(8) / 7) << endl;
    // 1.14286

流程控制语句

循环语句

while、for

int i = 0;
while (i < 100) {
    cout << i << endl;
    i++;
}

for (int j = 0; j < 100; j++) {
    cout << j << endl;
}

for (int j: {1, 2, 3}) {
    cout << j << endl;
}

int nums[] = {1, 2, 3, 4};
for (int j : nums) {
    cout << j << endl;
}

循环控制语句

continue：跳过当前循环，执行下一次循环

break：跳出当前循环

return：跳出当前函数，并返回一个值

分支语句

if-else、if-else if-else、switch

    int score = 98;
    if (score < 60) {
        cout << "Level: C" << endl;
    } else if (score < 90) {
        cout << "Level: B" << endl;
    } else {
        cout << "Level: A" << endl;
    }

    char grade = 'D';

    switch(grade) {
        case 'A' :
            cout << "很棒！" << endl;
            break;
        case 'B' :
        case 'C' :
            cout << "做得好" << endl;
            break;
        case 'D' :
            cout << "您通过了" << endl;
            break;
        case 'F' :
            cout << "最好再试一下" << endl;
            break;
        default :
            cout << "无效的成绩" << endl;
    }
    cout << "您的成绩是 " << grade << endl;

指针

一个变量，存放另一个变量的地址

目的：简化某些编程任务的执行

语法：数据类型 *变量名

指针变量的地址使用连字号（&）运算符访问

定义指针步骤：1. 变量变为指针 2. 把变量地址赋值给指针

如果把没有被赋值的变量的地址赋值给指针，输出指针内容会输出地址本身的值（随机值）

指针和变量的区别

变量在使用前必须要声明变量，且被赋值

指针拥有更高的权限，可以直接访问到地址本身的值，没被赋值的内存地址，也能输出

野指针

野指针是指针指向的位置是不可知的。（随机的、不正确的、没有明确限制的）

1. 使用未初始化的指针
2. 指针越界访问
3. 指针指向的空间被释放

如何规避野指针

1. 使用指针时，一定要进行赋值 (如果没有就赋值为空，即赋值nullptr)
2. 小心指针越界
3. 指针指向空间释放即使其置为空
4. 指针使用之前检查有效性 （例如：判断是否为空）

如果无法明确指针的数据类型，可以设置为void指针，表示指针类型不定，可指向任何数据类型的地址

pytorch中detach功能本质是拷贝一份值，不允许数据在梯度更新中修改原有的对象的值

引用

变量的别名

语法：数据类型 &变量名

引用和指针的区别

指针是一个新的变量，使用一个新的内存空间，存放变量的地址

引用没有创建新的变量，使用的仍是之前变量的地址

引用必须在创建时被初始化

指针可以在任何时间被初始化

引用的作用

把引用作为参数

把引用作为返回值

如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回

python中的=号是指初始化

函数

函数是对功能的封装，提高代码的复用性

定义函数需要注意：保证功能的唯一性

函数定义

返回类型 函数名(参数列表){ 函数主体 }

声明函数

需要先声明函数，然后再进行函数定义

#include <iostream>
using namespace std;
 
// 函数声明
int max(int num1, int num2);

// 函数返回两个数中较大的那个数
int max(int num1, int num2) 
{
   // 局部变量声明
   int result;
 
   if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}
 
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
   int ret;
 
   // 调用函数来获取最大值
   ret = max(a, b);
 
   cout << "Max value is : " << ret << endl;
 
   return 0;
}

函数参数

函数参数列表的参数是形式参数

抵用函数，有三种传递参数的方式

1. 传值调用：修改函数内的形式参数对实际参数没有影响
2. 指针调用：修改形式参数会影响实际参数
3. 引用调用：修改形式参数会影响实际参数

默认情况下，C++ 使用传值调用来传递参数

返回类型

无返回值，函数类型为void

有返回值，函数类型为数据类型，return返回数据类型的值

函数重载

不同的函数，使用了相同的函数名，但参数列表不同

编程思想

编程思想分为：面向过程、面向对象

面向对象的思想基于面向过程，是对面向过程的封装

面向过程：关注的是每一个动作（过程）

缺点：如果任何一个动作过程出现异常，或则顺序出错，程序就无法执行

面向对象：关注的是对象，对象封装了功能

优点：划分了不同功能代码的责任

面向对象的逻辑：找对象–>创建对象–>使用对象–>维护与对象之间的关系

对象

对象：真实存在的事物就是对象

对象由属性和功能构成

类

一个概念，是对对象的描述

类是由对象抽象而来

抽：提取；象：对象。抽象：提取对象的特征，进行归纳总结（概念）

类定义

class 类名{ 变量; 方法 };

类一定有属性和功能

访问数据成员，使用.访问

::表示后面的变量属于哪个对象

面向对象三大特征

封装

封装的本质是对对象的属性和功能进行保护

封装的方式：限制访问权限

访问修饰符

private：仅当前类可用（一般属性都设置为private，便于限制保护对象数据）

public：任何代码都可用（一般功能都设置为public）

protected：同一个package可用

继承

依据另一个类定义一个类

继承关系有：1. 父类–子类1–子类2–子类3；2. 父类1–父类2–父类3–子类

父类称为基类，子类称为派生类

一个类可以派生自多个类（继承于多个类）

注意：只能子类继承父类，如果父类继承子类，代码不会报错，但存在逻辑错误

继承的作用：降低代码的复用性，减少重复性代码

多态

基于继承，是指多种形态

子类覆写父类功能，优先调用父类功能（在父类的功能添加virtual关键字，可以让子类调用子类的功能）

virtual关键字：声明虚函数

附录：ASCII码

参考：ASCII 表 | 菜鸟教程 (runoob.com)