C++夯实基础

最新推荐文章于 2024-05-20 15:29:54 发布
最新推荐文章于 2024-05-20 15:29:54 发布
阅读量980 收藏 29
点赞数 35
文章标签： c++ java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69311549/article/details/136967421
版权

C++在线学习笔记

第一阶段：基础

一、环境配置

1.1.第一个程序（基本格式）

​

#include <iosteam>
using namespace std;

int main(){
	cout<<"hello world"<<endl;
	system("pause");
}

​ 模板

#include <iosteam>
using namespace std;
#include <string.h>
int main(){
	//主要功能代码区
    
    
	system("pause");
}
1.2注释

image-20240312180130454

1.3变量

​ 意义：方便管理内存空间

​ 方法：数据类型 变量名 = 数字；

#include <iosteam>
using namespace std;

int main(){
	int a = 10; 
	cout<<"a = "<<a<<endl;
	system("pause");
}
1.4常量

image-20240312180534938

#include <iosteam>
using namespace std;
#def Day 7
int main(){
  
	cout<<"一周一共有"<<Day<<endl;
	system("pause");
  
}
1.5关键字

image-20240312180905002

1.6变量命名规则

image-20240312181052920

二、数据类型

​ 目的：给数据存分配合适的空间大小；避免资源浪费

2.1整形

​ image-20240312181159521

2.2 sizeof

image-20240312182020423

int main(){
	cout<<"short类型内存为："<<sizeof(short)<<endl;
}

image-20240312182218512

2.3浮点型

image-20240312182322358

image-20240312182606364

​ float占用四个字节

​ double占用八个字节

​ 科学计数法

​ image-20240312182812067

2.4字符型

​ 注意事项：单引号；单引号里面只能放一个；ASCII值；int（char）；A65；a97.

​ image-20240312182913797

2.5转义字符

image-20240313080814589

2.6字符串型

​ #include string

​ string a = “你好世界” //C++中的变量

​ char str[] =“Hello world” //C中的

image-20240313081406116

2.7布尔数据类型

image-20240313081756468

2.8数据的输入

image-20240313081956558

#include <iosteam>
using namespace std;
#include <string>

int main(){
  int a =0;
	cout<<"请给a赋值 = "<<endl;
  cin>>a;把输入的值赋值给a
  cout<<"a = "<<a<<endl;
  
  char b ='a';
	cout<<"请给b赋值 = "<<endl;
  cin>>a;把输入的值赋值给a
  cout<<"b = "<<a<<endl;
  
	system("pause");
  
}

三、运算符

image-20240313082511741

3.1 算术运算符号

image-20240313082546265

#include <iostream>
using namespace std;

int main() {
    int num1, num2;
    cout << "请输入两个整数：" << endl;
    cin >> num1 >> num2;

    // 加法
    int sum = num1 + num2;
    cout << "加法结果：" << sum << endl;

    // 减法
    int difference = num1 - num2;
    cout << "减法结果：" << difference << endl;

    // 乘法
    int product = num1 * num2;
    cout << "乘法结果：" << product << endl;

    // 除法
    if (num2 != 0) {
        double quotient = static_cast<double>(num1) / static_cast<double>(num2);
        cout << "除法结果：" << quotient << endl;
    } else {
        cout << "除数不能为0" << endl;
    }

    return 0;
}

image-20240313083645770

image-20240313084009944

3.2赋值运算符

image-20240313084101731

#include <iostream>
using namespace std;

int main() {
    int a = 10; // 直接赋值
    cout << "a = " << a << endl;

    a += 5; // 加法赋值
    cout << "a = " << a << endl;

    a -= 3; // 减法赋值
    cout << "a = " << a << endl;

    a *= 2; // 乘法赋值
    cout << "a = " << a << endl;

    a /= 4; // 除法赋值
    cout << "a = " << a << endl;

    a %= 6; // 取模赋值
    cout << "a = " << a << endl;
    
    int v = 10;
    ++v ;
    cout<<"v = "<<v<<endl;
  
  

    return 0;
}
3.3比较运算符

image-20240313084313494

#include <iostream>
using namespace std;

int main() {
    int a = 10, b = 20;

    // 等于运算符
    if (a == b) {
        cout << "a等于b" << endl;
    } else {
        cout << "a不等于b" << endl;
    }

    // 不等于运算符
    if (a != b) {
        cout << "a不等于b" << endl;
    } else {
        cout << "a等于b" << endl;
    }

    // 大于运算符
    if (a > b) {
        cout << "a大于b" << endl;
    } else {
        cout << "a不大于b" << endl;
    }

    // 小于运算符
    if (a < b) {
        cout << "a小于b" << endl;
    } else {
        cout << "a不小于b" << endl;
    }

    // 大于等于运算符
    if (a >= b) {
        cout << "a大于等于b" << endl;
    } else {
        cout << "a小于b" << endl;
    }

    // 小于等于运算符
    if (a <= b) {
        cout << "a小于等于b" << endl;
    } else {
        cout << "a大于b" << endl;
    }
	system("pause");
    return 0;
}
3.4逻辑运算

image-20240313084600685

#include <iostream>
using namespace std;

int main() {
    bool a = true, b = false;

    // 与运算符
    if (a && b) {
        cout << "a和b都为真" << endl;
    } else {
        cout << "a和b不都为真" << endl;
    }

    // 或运算符
    if (a || b) {
        cout << "a和b至少有一个为真" << endl;
    } else {
        cout << "a和b都不为真" << endl;
    }

    // 非运算符
    if (!a) {
        cout << "a为假" << endl;
    } else {
        cout << "a为真" << endl;
    }
	system("pause");
    return 0;
}

四、 程序流程结构

image-20240313085000656

4.1顺序结构
#include <iostream>
using namespace std;

int main() {
    int num = 0;

    // if语句
    if (num > 0) {
        cout << "num大于0" << endl;
    } else if (num < 0) {
        cout << "num小于0" << endl;
    } else {
        cout << "num等于0" << endl;
    }

    return 0;
}

if (条件表达式) {
    // 当条件表达式为真时执行的代码块
} else if (条件表达式) {
    // 当第一个条件表达式为假，且当前条件表达式为真时执行的代码块
} else {
    // 当所有条件表达式都为假时执行的代码块
}

别加分号

4.2选择顺序结构

#include <iostream>
using namespace std;
int main() {
    int score = 0;
    cout << "输入分数" << endl;
    cin >> score;
    cout << "您的分数为：" << score << endl;

    if (score > 600) {
        cout << "恭喜你考上了一本大学" << endl;
    }
    else if (500 < score < 600) {
        cout << "恭喜你考上了二本大学" << endl;
    }
    else if (400 < score < 500) {
        cout << "恭喜你考上了二本大学" << endl;
    }

    system("pause");
    return 0;


}
4.2嵌套语句

​ 案例一需求

image-20240317185320906

​ 代码实现

#include <iostream>
using namespace std;

int main() {
    int score;
    cout << "请输入高考考试分数： ";
    cin >> score;

    if (score > 600) {
        cout << "考上一本" << endl;
        if (score > 700) {
            cout << "考入北大" << endl;
        } else if (score > 650) {
            cout << "考入清华" << endl;
        } else if (score > 600) {
            cout << "考入人大" << endl;
        }
    } else if (score > 500) {
        cout << "考上二本" << endl;
    } else if (score > 400) {
        cout << "考上三本" << endl;
    } else {
        cout << "未考上本科" << endl;
    }

    return 0;
}

​ 案例二需求----三只小猪称体重
​ image-20240317185659667

​ 代码实现：
​

#include <iostream>
using namespace std;

int main() {
    int weightA, weightB, weightC;
    cout << "请输入小猪A的体重：";
    cin >> weightA;
    cout << "请输入小猪B的体重：";
    cin >> weightB;
    cout << "请输入小猪C的体重：";
    cin >> weightC;

    if (weightA >= weightB && weightA >= weightC) {
        cout << "小猪A最重" << endl;
    } else if (weightB >= weightA && weightB >= weightC) {
        cout << "小猪B最重" << endl;
    } else {
        cout << "小猪C最重" << endl;
    }

    return 0;
}
4.3 三目运算符：

​ 要求

image-20240317191530535

​ 代码实现：

#include <iostream>
using namespace std;

int main() {
    int weightA, weightB, weightC;
    cout << "请输入小猪A的体重：";
    cin >> weightA;
    cout << "请输入小猪B的体重：";
    cin >> weightB;
    cout << "请输入小猪C的体重：";
    cin >> weightC;

    string heaviest = (weightA >= weightB && weightA >= weightC) ? "小猪A" : (weightB >= weightA && weightB >= weightC) ? "小猪B" : "小猪C";
    cout << heaviest << "最重" << endl;

    return 0;
}

​ 注意：？是判断的意思

​ 就是":"就是否则就的意思
image-20240317192158943

4.4 switch语句
#include <iostream>
using namespace std;

int main() {
    int weightA, weightB, weightC;
    cout << "请输入小猪A的体重：";
    cin >> weightA;
    cout << "请输入小猪B的体重：";
    cin >> weightB;
    cout << "请输入小猪C的体重：";
    cin >> weightC;

    string heaviest;
    if (weightA >= weightB && weightA >= weightC) {
        heaviest = "小猪A";
    } else if (weightB >= weightA && weightB >= weightC) {
        heaviest = "小猪B";
    } else {
        heaviest = "小猪C";
    }

    switch (heaviest[0]) {
        case '小':
            cout << "最重的小猪是" << heaviest << endl;
            break;
        default:
            cout << "没有找到最重的小猪" << endl;
            break;
    }

    return 0;
}
4.5循环结构

​ 4.5.1结构浏览
image-20240317192547410

​ 4.5.2打印数字

int main(){
    int num = 0;
    cout<<num<<endl;
    
    while(num<10){
        cout<<num<<endl;
        num++;
    }
    
    
    system("puase");
}

​ 4.5.3猜数字案例
image-20240317193127126

#include <iostream>
#include <ctime>
#include <cstdlib>

int main() {
    srand(time(0));
    int random_num = rand() % 100 + 1;//rand() % 100生成一个0--99的树
    int guess;

    std::cout << "欢迎来到猜数字游戏！系统已生成一个1到100之间的随机数，请开始猜测：" << std::endl;

    while (true) {
        std::cin >> guess;
        if (guess > random_num) {
            std::cout << "猜大了，请重新输入：" << std::endl;
        } else if (guess < random_num) {
            std::cout << "猜小了，请重新输入：" << std::endl;
        } else {
            std::cout << "恭喜你猜对了！游戏结束。" << std::endl;
            break;
        }
    }

    return 0;
}

​ 4.5.4 do while 实现

#include <iostream>
#include <ctime>
#include <cstdlib>

int main() {
    srand(time(0));
    int random_num = rand() % 100 + 1;
    int guess;
    bool isCorrect = false;

    std::cout << "欢迎来到猜数字游戏！系统已生成一个1到100之间的随机数，请开始猜测：" << std::endl;

    do {
        std::cin >> guess;
        if (guess > random_num) {
            std::cout << "猜大了，请重新输入：" << std::endl;
        } else if (guess < random_num) {
            std::cout << "猜小了，请重新输入：" << std::endl;
        } else {
            std::cout << "恭喜你猜对了！游戏结束。" << std::endl;
            isCorrect = true;
        }
    } while (!isCorrect);

    return 0;
}

​ 4.5.5水仙花数的实现
image-20240317201245061

解决办法：
image-20240317201326550

image-20240317201728843

#include <iostream>
#include <cmath>

bool is_narcissistic_number(int num) {
    int sum = 0;
    int temp = num;
    int n = std::to_string(num).length();

    while (temp > 0) {
        int digit = temp % 10;
        sum += std::pow(digit, n);
        temp /= 10;
    }

    return sum == num;
}

int main() {
    for (int i = 100; i <= 999; ++i) {
        if (is_narcissistic_number(i)) {
            std::cout << i << " 是水仙花数" << std::endl;
        }
    }

    return 0;
}
4.6 for循环

image-20240317202042282

int main(){
    for(int i = 0;i<10;i++){
        cout<<"i = "<<i<<endl;
    }
    system("pause");
}

​ 案例：敲桌子
image-20240317202327882

​ 思路：

image-20240317202439721

image-20240317202548012

​ 代码

#include <iostream>
using namespace std;

bool contains_seven(int num) {
    while (num > 0) {
        if (num % 10 == 7) {
            return true;
        }
        num /= 10;
    }
    return false;
}

bool is_multiple_of_seven(int num) {
    return num % 7 == 0;
}

int main() {
    int num;
    cout << "请输入一个数字： ";
    cin >> num;

    if (contains_seven(num) || is_multiple_of_seven(num)) {
        cout << "敲桌子" << endl;
    } else {
        cout << "不敲桌子" << endl;
    }

    return   0;
}

​ 嵌套循环
image-20240317202814435

​ 代码实现：
image-20240317203003897

​ 乘法口诀表
image-20240317203042916

​ 代码实现：

#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 9; ++i) {
        for (int j = 1; j <= i; ++j) {
            cout << j << " * " << i << " = " << i * j << "\t";
        }
        cout << endl;
    }

    return 0;
}

​ 结果：
image-20240317203649985

4.7跳转语句

break
image-20240317203740707

#include <iostream>
using namespace std;

int main() {
    for (int i = 0; i < 10; ++i) {
        if (i == 5) {
            break; // 当i等于5时跳出循环
        }
        cout << i << " ";
    }
    cout << endl;

    for (int i = 0; i < 10; ++i) {
        if (i % 2 == 0) {
            continue; // 当i是偶数时跳过本次循环
        }
        cout << i << " ";
    }
    cout << endl;

    return 0;
}

​ continue代码

#include <iostream>
using namespace std;

int main() {
    for (int i = 0; i < 10; ++i) {
        if (i % 2 == 0) {
            continue; // 当i是偶数时跳过本次循环
        }
        cout << i << " ";
    }
    cout << endl;

    return 0;
}


break和continue的区别：
			**break用于结束整个循环，而continue用于跳过当前迭代继续执行后续迭代**。

在编程中，break和continue都是控制流程的关键字，它们影响循环结构的行为。以下是两者的具体区别：

  • 作用范围：当在循环内部遇到break时，会立即退出最内层的循环，并开始执行循环之后的代码。而continue仅跳过当前的迭代，即本次循环剩余未执行的部分，然后继续进行下一次迭代。
  • 使用场景：break通常用于在满足某个条件时要完全终止循环的情况。例如，你可能在一个搜索算法中找到目标值后使用break来停止搜索。continue则用于当某次迭代不满足特定条件时，希望略过此次迭代，直接进入下一次迭代的情况。比如，在遍历一个数组时，可能需要忽略某些特定的值。

总结来说，break和continue虽然都可以用来控制循环结构，但它们的主要区别在于break用于结束整个循环，而continue用于结束当前迭代并继续执行后续的迭代。

4.8 goto语句

C++中的goto语句是一种跳转语句，用于将程序的执行流程跳转到指定的标签位置。它的语法格式如下：

goto label;
...
label: statement;

其中，label是一个用户自定义的标签，可以是一个标识符或者一个数字。当程序执行到goto语句时，它会跳转到与该标签对应的位置，并从该位置开始执行后面的语句。需要注意的是，使用goto语句可能会导致代码结构混乱，不易于维护和调试，因此在实际编程中应尽量避免使用。

#include <iostream>
using namespace std;

int main() {
    int num = 0;
    start: // 标签
    num++;
    cout << "num: " << num << endl;
    if (num < 5) {
        goto start; // 跳转到start标签
    }
    return 0;
}

五、 数组

image-20240317204658499

5.1 数组的定义

数组是一组具有相同数据类型的元素的集合，这些元素在内存中连续存放，并且每个元素都可以通过下标来访问。

数组的定义通常包括以下几个要素：

  1. 数据类型：数组中每个元素的类型，如int、float、char等。
  2. 数组名：用于标识数组的变量名。
  3. 数组大小：可以是声明时指定的常量表达式，也可以是后续动态分配的大小。
  4. 初始化：可以在声明时对数组进行初始化，也可以在声明后对数组的元素逐一赋值。
  5. 访问：通过数组名和下标来访问或修改数组中的元素。

此外，在C语言中，数组的下标是从0开始的，所以如果有一个数组a，那么a[0]表示第一个元素，a[n-1]表示最后一个元素，其中n是数组的大小。

总的来说，数组是编程中非常基础且重要的概念，它不仅用于存储数据，还常常用于处理大量数据的情况，如数值计算、数据处理等场景。

5.2数组的操作

数组的操作主要包括以下几个方面：

  1. 访问数组元素：通过下标来访问数组中的元素，例如a[0]表示第一个元素，a[n-1]表示最后一个元素。
  2. 修改数组元素：通过下标来修改数组中的元素，例如a[0] = 10将第一个元素的值改为10。
  3. 遍历数组元素：使用循环结构来遍历数组中的所有元素，例如使用for循环或while循环。
  4. 数组排序：对数组进行排序，可以使用内置的排序函数或者自定义的排序算法。
  5. 查找数组元素：在数组中查找指定的元素，可以使用线性查找、二分查找等方法。
  6. 动态数组：根据需要动态地增加或减少数组的大小，可以使用C语言中的realloc函数或者C++中的vector容器。
5.3代码的实现

以下是使用C语言实现数组操作的示例代码：

#include <stdio.h>

int main() {
    // 定义一个整型数组，大小为5
    int a[5] = {1, 2, 3, 4, 5};

    // 访问数组元素
    printf("a[0] = %d", a[0]); // 输出第一个元素
    printf("a[4] = %d", a[4]); // 输出最后一个元素

    // 修改数组元素
    a[0] = 10;
    printf("a[0] = %d", a[0]); // 输出修改后的第一个元素

    // 遍历数组元素
    for (int i = 0; i < 5; i++) {
        printf("a[%d] = %d", i, a[i]);
    }

    // 动态增加数组大小
    int *b = (int *)realloc(a, 10 * sizeof(int));
    if (b != NULL) {
        a = b;
        for (int i = 5; i < 10; i++) {
            a[i] = i + 1;
        }
        printf("New array: ");
        for (int i = 0; i < 10; i++) {
            printf("%d ", a[i]);
        }
        printf("");
    } else {
        printf("Failed to resize the array.");
    }

    return 0;
}

以上代码演示了如何定义、访问、修改、遍历和动态调整数组的大小。其中，realloc函数用于重新分配内存空间，如果分配成功则返回指向新内存空间的指针，否则返回NULL。

5.4 一维数组的作用

image-20240317205341713

一维数组是编程中非常基础且重要的概念，它的作用主要有以下几个方面：

  1. 存储数据：一维数组可以用于存储一组相同类型的数据，例如整数、浮点数、字符等。通过下标访问和修改数组元素，可以实现对数据的快速存取和修改。

  2. 处理大量数据：在处理大量数据时，使用一维数组可以有效地减少内存占用和提高程序运行效率。例如，在数值计算、数据处理、图像处理等领域，一维数组被广泛应用。

  3. 实现算法：许多算法需要使用到数组，例如排序算法、查找算法、动态规划等。一维数组作为这些算法的基础数据结构，能够方便地实现各种算法。

  4. 简化代码：使用一维数组可以将复杂的数据结构和操作抽象化，从而简化代码的编写和维护。例如，在字符串处理、矩阵运算等领域，一维数组可以大大简化代码的复杂度。

  5. 统计数组的大小：

    以下是使用C语言实现统计数组大小的示例代码：

    #include <stdio.h>

int main() {
    // 定义一个整型数组，大小为5
    int a[5] = {1, 2, 3, 4, 5};

    // 计算数组的大小
    int size = sizeof(a) / sizeof(a[0]);
    printf("The size of the array is %d
", size); // 输出数组的大小

    return 0;
}

    以上代码中，sizeof(a)可以获取整个数组的字节数，而sizeof(a[0])可以获取数组中每个元素的字节数。将两者相除即可得到数组的大小。需要注意的是，这种方法只适用于在定义数组时已知数组大小的情况，如果数组是通过动态分配内存得到的，则需要使用其他方法来获取数组的大小。

  6. 案例一：

    1. image-20240317205936051

    2. 解析：首先需要遍历数组，找到最大值，然后打印出来。

      代码如下：

      #include <iostream>
using namespace std;

int main() {
    int arr[5] = {300, 350, 200, 400, 250};
    int max_weight = arr[0];

    for (int i = 1; i < 5; i++) {
        if (arr[i] > max_weight) {
            max_weight = arr[i];
        }
    }

    cout << "最重的小猪体重为：" << max_weight << endl;
    return 0;
}

案例二：

image-20240317210309164

代码实现：

​ 解析：首先需要声明一个5个元素的数组，然后通过循环将数组元素逆置。

代码如下：

#include <iostream>
using namespace std;

int main() {
    int arr[5] = {1, 3, 2, 5, 4};

    for (int i = 0; i < 5 / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[4 - i];
        arr[4 - i] = temp;
    }

    for (int i = 0; i < 5; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

​ image-20240317235042872

案例三：冒泡排序

冒泡排序是一种简单直观的交换排序算法。

冒泡排序的基本思想是通过重复遍历要排序的数列，比较相邻两个元素的大小，如果顺序错误（例如，第一个元素比第二个大），则交换它们的位置。这个过程会不断重复，直到整个数列被排序完成。具体步骤如下：

  1. 比较相邻元素：从数列的第一个元素开始，依次比较相邻的两个元素，如果前一个元素大于后一个元素，则交换这两个元素的位置。
  2. 重复遍历：完成一轮遍历后，最大的元素会被移动到数列的末尾。然后再次从头开始遍历，重复上述比较和交换的过程。
  3. 确定元素归位：每完成一趟遍历，就能确定一个元素归位，即该元素移动到了它最终应该在的位置上。
  4. 判断排序完成：当进行一轮遍历后没有任何元素需要交换，说明数列已经完全有序，排序过程结束。

总的来说，冒泡排序的名称来源于较小的元素会逐渐“冒泡”到数列的顶端，就像水中的气泡一样向上浮动。尽管冒泡排序在最坏情况下的时间复杂度较高（O(n^2)），但由于其算法简单且易于实现，它仍然在某些教学场合和特定应用场景中得到使用。

image-20240317235430567

图示

image-20240317235918108

image-20240318000231710

代码部分

#include <stdio.h>
#include <stdlib.h> // rand() srand()
#include <time.h>   // time()

void display(int* array, int size); // 打印函数
int  check(int* array, int size);   // 检查函数
void swap(int* a, int* b);          // 交换函数

/**
 * @brief 冒泡排序：重的往下沉，从小到大
 *
 * @param array        数组首地址
 * @param size         数组大小
 */
void bubble_sort(int* array, int size)
{
    // 外循环为排序趟数，size 个数进行 size-1 趟
    // 内循环为每趟比较的次数，第 i 趟比较 size-1-i 次
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                swap(&array[j], &array[j + 1]);
            }
        }
    }
}

void bubble_sort_better(int* array, int size)
{
    for (int i = 0; i < size - 1; i++) {
        // 以 flag 作为标志，如果遍历完没有改变说明有序不再遍历排序
        int flag = 1;
        for (int j = 0; j < size - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                swap(&array[j], &array[j + 1]);
                flag = 0;
            }
        }
        if (flag) {
            break;
        }
    }
}

int main()
{
    // 测试用例
    // int array[]    = {49, 38, 65, 97, 76, 13, 27, 49, 10};
    // int array_size = sizeof(array) / sizeof(array[0]);
    // printf("%d \n", array_size);
    // printf("排序前数组：");
    // display(array, array_size);
    // bubble_sort(array, array_size);
    // printf("排序后数组：");
    // display(array, array_size);

    // 随机测试
    int array_num  = 20;             // 数组数量
    int array_size = 20;             // 数组大小
    int array[array_size];           // 数组初始化
    srand((unsigned int)time(NULL)); // 随机数种子，保证每次不一样
    for (int i = 0; i < array_num; i++) {
        for (int j = 0; j < array_size; j++) {
            array[j] = rand() % 1000; // 随机生成数大小 0~999
        }
        printf("原来的数组：");
        display(array, array_size);
        bubble_sort(array, array_size);
        printf("排序后数组：");
        display(array, array_size);
        // 检测排序结果
        if (check(array, array_size) != 0) {
            exit(-1);
        }
        printf("\n");
    }

    return 0;
}

/**
 * @brief 打印函数
 *
 * @param array        数组首指针
 * @param size         数组大小
 */
void display(int* array, int size)
{
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
}

/**
 * @brief 检查函数，从小到大
 *
 * @param array        数组首指针
 * @param size         数组大小
 */
int check(int* array, int size)
{
    for (int i = 0; i < size - 1; i++) {
        if (array[i] > array[i + 1]) {
            printf("sort array fail...\n");
            return -1;
        }
    }
    printf("sort array success...\n");
    return 0;
}

/**
 * @brief 交换函数
 *
 * @param a            第一个交换地址
 * @param b            第二个交换地址
 */
void swap(int* a, int* b)
{
    int temp = *b;
    *b       = *a;
    *a       = temp;
}

总之，一维数组是编程中非常重要的数据结构之一，它不仅能够存储和处理大量数据，还能够实现各种算法和简化代码。

5.5 二维数组

5.5.1 数组的定义

image-20240318000720469

在程序员的术语中，二维数组可以被理解为一个数据结构，它以行和列的形式组织数据，形成一个类似于表格或矩阵的结构。它是一维数组的一个扩展，而一维数组可以被视为一个线性序列。

具体来说，二维数组可以想象为一个由多个一维数组构成的数组，其中每个一维数组代表二维数组的一行。这些一维数组（行）具有相同的长度，这个长度定义了二维数组的列数。因此，二维数组通常通过其行数和列数来描述其大小。

在内存中，二维数组通常是连续存储的，即第一行的所有元素紧跟着第二行的元素，依此类推。这允许通过索引公式直接访问任何特定元素。例如，如果我们有一个名为array的二维数组，要访问位于第i行第j列的元素，我们通常使用array[i][j]的形式（在大多数编程语言中）。

在不同的编程语言中，二维数组的声明和初始化方式可能会有所不同。以下是几种不同语言中声明二维数组的例子：

  • C/C++:

    int array[3][4]; // 一个有3行4列的整型二维数组

  • Java:

    int[][] array = new int[3][4]; // 一个有3行4列的整型二维数组

  • Python (在Python中称为列表的列表):

    array = [[0 for _ in range(4)] for _ in range(3)] # 一个有3行4列的整型二维数组

二维数组在各种编程任务中都非常有用，包括图像处理、地图表示、游戏开发中的网格系统等。通过它们，开发者能够方便地处理有着行列逻辑关系的数据集。

5.5.2 数组名的作用

  1. 查询数组的占内存的大小

  2. 查看二维数组的首地址

  3. 代码实现：

    #include<stdio.h>
using namespace std;

int main(){
	int arr[2][3] ={
		{1,2,3},
		{4,5,6}
}
	cout<<"二维数组占用内存空间为："<<sizeof(arr)<<endl;
	cout<<"二维数组第一行占用内存空间为："<<sizeof(arr[0])<<endl;
	cout<<"二维数组第一个元素占用内存空间为："<<sizeof(arr[0][0])<<endl;

    
}

image-20240318145114550

#include <iostream>

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int *p = arr;

    std::cout << "数组首地址： " << &arr[0] << std::endl;
    std::cout << "指针指向的首地址： " << p << std::endl;

    return 0;
}

image-20240318145420794

5.5.3二维数组的案例

image-20240318145524516

方法和思想

  1. 创建二维数组

  2. 统计考试成绩，让每行数据相加，统计出总和

  3. 代码实现

    #include <stdio.h>
using namespce std;
#include <string.h>

int main(){
    int scores =[3][3] = {
        {100,100,100},
        {90,55,100},
        {60,70,80}
    }
    //统计求和
    for(int i = 0;i<3;i++){
        sum = 0;
        for(int j = 0;j<3;j++){
            sum = sum +score[i][j];
        }
        cout<<"第"<<i+1<<"个人的成绩总和为"<<sum<<endl;
        
    }
}
5.6函数

image-20240318151222840

为了实现算术运算，我们可以创建一个C++函数，该函数接受两个参数（操作数）和一个字符（运算符），然后根据运算符执行相应的算术运算。以下是一个示例：

#include <iostream>
using namespace std;

double arithmeticOperation(double num1, double num2, char operation) {
    double result;

    switch (operation) {
        case '+':
            result = num1 + num2;
            break;
        case '-':
            result = num1 - num2;
            break;
        case '*':
            result = num1 * num2;
            break;
        case '/':
            if (num2 != 0) {
                result = num1 / num2;
            } else {
                cout << "除数不能为0" << endl;
                exit(0);
            }
            break;
        default:
            cout << "无效的运算符" << endl;
            exit(0);
    }

    return result;
}

int main() {
    double num1, num2;
    char operation;

    cout << "请输入第一个操作数： ";
    cin >> num1;
    cout << "请输入第二个操作数： ";
    cin >> num2;
    cout << "请输入运算符(+, -, *, /): ";
    cin >> operation;

    double result = arithmeticOperation(num1, num2, operation);
    cout << "结果： " << result << endl;
	system("pause");
    return 0;
}

这个程序首先定义了一个名为arithmeticOperation的函数，该函数接受两个double类型的参数（操作数）和一个char类型的参数（运算符）。然后，它使用switch语句根据运算符执行相应的算术运算，并返回结果。在main函数中，我们从用户那里获取操作数和运算符，然后调用arithmeticOperation函数并输出结果。

image-20240318151656530

运行结果：

image-20240318151404046

值传递

#include <iostream>
using namespace std;

//形参传递
void swap(int num1, int num2) {
    int temp = num1;
    num1 = num2;
    num2 = temp;
    cout << "swap中 num1 =" << num1 << "swap中 num2 =" << num2 << endl;
}


//值传递

void swap1(int &num1, int &num2) {
    int temp = num1;
    num1 = num2;
    num2 = temp;
    cout << "swap1中 num1 =" << num1 << "swap1中 num2 =" << num2 << endl;
}

int main() {
    int a = 10;
    int b = 20;
    swap(a, b);
    cout << "main中 num1 =" << a << "main中 num2 =" << b << endl;

    swap1(a, b);
    cout << "二次调用main中 num1 =" << a << "main中 num2 =" << b << endl;
    system("pause");
    return 0;

}

函数的常见样式

image-20240318153355144

C++中函数的常见样式有以下几种：

  1. 无参数，无返回值的函数：
void functionName() {
    // 函数体
}
  1. 有参数，无返回值的函数：
void functionName(parameterType parameterName) {
    // 函数体
}
  1. 无参数，有返回值的函数：
returnType functionName() {
    // 函数体
    return returnValue;
}
  1. 有参数，有返回值的函数：
returnType functionName(parameterType parameterName) {
    // 函数体
    return returnValue;
}

其中，returnType表示函数的返回值类型，functionName表示函数名，parameterType表示参数类型，parameterName表示参数名。

函数的声明

C++函数的声明、定义和作用：

  1. 声明：函数声明是告诉编译器函数的名称、返回类型和参数列表。函数声明通常放在头文件中，以便在多个源文件中使用同一个函数时，编译器可以知道函数的存在。

  2. 定义：函数定义是实现函数的具体功能。函数定义包括函数体，即实现函数功能的代码块。

  3. 作用：函数的作用是将一段具有特定功能的代码封装起来，以便在程序中多次调用。通过使用函数，可以提高代码的复用性和可维护性。

相关案例实现：

#include <iostream>
using namespace std;

// 函数声明 不用具体的函数的实现 只是声明 int add(int a,int b);
int add(int a, int b);

int main() {
    int num1, num2, sum;

    cout << "请输入两个整数：" << endl;
    cin >> num1 >> num2;

    // 调用函数
    sum = add(num1, num2);

    cout << "两数之和为：" << sum << endl;

    return 0;
}

// 函数定义
//pass 复习一下：a>b?a:b
int add(int a, int b) {
    return a + b;
}

在这个案例中，我们定义了一个名为add的函数，用于计算两个整数的和。首先，我们在main函数中获取用户输入的两个整数，然后调用add函数计算它们的和，并将结果输出到屏幕上。

函数的分文件编写

image-20240318154402943

在C++中，实现函数的分文件编写通常需要将函数声明放在头文件中，而将函数定义放在源文件中。以下是一个简单的示例：

  1. 创建一个头文件（例如：functions.h）：
    image-20240318155005452
#ifndef FUNCTIONS_H
#define FUNCTIONS_H

// 函数声明
int add(int a, int b);

#endif // FUNCTIONS_H
  1. 创建一个源文件（例如：functions.cpp）：
    image-20240318155140612
#include "functions.h"

// 函数定义
int add(int a, int b) {
    return a + b;
}

  1. 在头文件中剪切源文件中函数的声明
    void swap(int num1, int num2);

    image-20240318155512776

  2. 在源文件中声明函数的定义，并且引用头文件
    image-20240318160217684

  3. 在头文件导入标准的输入输出文件 标准的命名空间std和函数声明
    image-20240318160332909

  4. 在主程序中使用这些函数：

#include <iostream>
#include "functions.h"

int main() {
    int num1, num2, sum;

    std::cout << "请输入两个整数：" << std::endl;
    std::cin >> num1 >> num2;

    sum = add(num1, num2);

    std::cout << "两数之和为：" << sum << std::endl;

    return 0;
}

在这个示例中，我们将函数声明放在了头文件中，而将函数定义放在了源文件中。这样，我们可以在多个源文件中使用这个函数，而不需要重复编写函数的定义。

5.7指针

在C++中，指针是一种特殊的变量，它存储着另一个变量的内存地址。指针的基本概念、作用和使用方式具体如下：

  • 基本概念：指针是一种变量，它存储的是另一变量的地址。这个地址是内存中的一个位置，而这个位置上存储的就是数据。通过指针，可以间接访问和修改这个地址上的数据。

  • 作用：指针在C++编程中扮演着重要角色，它们允许程序员直接操作内存，这为程序的灵活性和效率带来了提升。指针的使用可以帮助实现动态内存分配、函数参数的传递、构建复杂的数据结构如链表和树等，以及支持多维数组和其他高级功能。

  • 使用方式：

  • 声明：使用星号（*）来声明一个指针变量。例如，int *ptr; 声明了一个指向整型的指针变量ptr。

  • 初始化：指针可以通过获取变量的地址(&)来初始化，如int val = 10; int *ptr = &val;，此时ptr指向val的地址。

  • 解引用：可以使用星号（*）来访问指针指向地址上的值，如int value = *ptr;，这样就将ptr指向地址上的值赋给了value。

  • 指针运算：指针可以进行加减运算，以移动到连续内存块中的其他元素，也可以进行比较运算来确定两个指针的相对位置。

总的来说，掌握指针的使用对于编写高效和灵活的C++代码至关重要。通过深入理解指针的原理和常见操作，程序员能够更加熟练地使用指针来访问和操作内存中的数据。

第二阶段：核心

第三阶段：提高

吹泡泡的派大星
关注
  • 35
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++Builder 6.0设计师之路 pdf版
04-01
本书是一本指导读者如何最大程度地使用c++ builder 6.0进行代码开发的就业指南。书中详细介绍了关键的编程概念和利用vcl环境来开发应用程序的基础知识，还提供了上百个如何在vcl环境下使用c++ builder功能的技巧、具有实践性的建议以及数百个可以立即运行的重要解决方案的详细代码，内容主要涉及以下几个方面：标准c++基础知识、vcl库、windows窗体、图形编程、多线程技术、数据库应用、分布式应用、web等等。通过本书的学习，读者可以高效的利用c++ builder开发应用程序，能够理解关键操作的内部实现机制，有助于迅速利用c++ builder来实现大量的编程任务，成为一个成功的设计师。 本书适用于大中专院校学生、程序设计人员和c++ builder爱好作为为一本就业实践指南。 目录 ↑第一部分 学习——跨越求职路上的鸿沟 第1章 夯实c++基本功 1.1 初步认识c++基本功 1.2 类型和表达式 1.3 控制结构 1.4 指针和数组 1.5 函数 1.6 结构和枚举 第2章 如何实现面向对象编程 2.1 类和对象 2.2 友元类和友元函数 2.3 类的继承 2.4 多态和虚函数 第3章 异常处理3.1 3.2 win32平台的结构优异常处理 3.3 c++异常处理 第二部分 实践——享受c++builder，享受工作的乐趣 第4章 参观c++builder的开发环境 4.1 了解集成开发环境 4.2 项目管理工具 .4.3 编译和调试的方法 4.4 如何开发一个完整的工程 第5章 使用类库 5.1 vcl库中的类结构 5.2 组件的控件之间的关系 5.3 理解属性、方法和事件 5.4 通用的属性、方法和事件 5.5 与应用程序息息相关的类 第6章 设计用户界面 6.1 利用按钮与用户交互 6.2 静态文本显示类控件的操作 6.3 用户输入类控件的应用 6.4 状态类控件的应用 6.5 选项类控件的应用 6.6 分页控件 6.7 大纲视图类控件 6.8 如何在窗口上显示图形 6.9 tframe的使用 6.10 管理菜单 6.11 工具栏和酷栏 6.12 使用动作列表 第7章 图形编程 7.1 图形的简单显示 7.2 设备描述表与tcanvas类 7.3 gdi对象 7.4 基本绘图操作 第8章 文件和目录操作 8.1 标准文件类型 8.2 常用文件操作函数 8.3 文件操作对话框 8.4 如何获取驱动器类型 8.5 操作jni文件 8.6 获取文件的日期信息 8.7 检测软盘或光碟是否有过变化 8.8 检测驱动器容量 8.9 复制整个目录 8.10 将文件删除到回收站中 8.11 检测驱动器是否就绪 8.12 操作临时文件 第9章 打印的实现 9.1 用对话框设置打印 9.2 简便的打印 9.3 tprinter类 9.4 获取默认打印机信息 9.5 获取打印队列的信息 9.6 如何打印位图 第10章 注册表 10.1 注册表键 10.2 注册表数据类型 10.3 使用tregistry 第11章 多线程的处理 11.1 如何创建并运行一个线程 11.2 在vcl中使用线程 11.3 如何控制线程的优化级 11.4 如何挂起和唤醒线程 11.5 如何协调线程之间的工作 第三部分 价值提升_走上专家之路,做个真正的设计师 第12章 数据库技术 12.1 用ado连接数据库 12.2 如何连接到数据源 12.3 如何从数据源取出数据 12.4 如何对数据集中的数据进行操作 12.5 如何创建主线表 12.6 如何使用字段组件 12.7 数据集的状态 12.8 用adocommand直接对数据源进行操作 第13章 分布多层应用 13.1 为什么要使用分布式多层结构 13.2 理解midas 13.3 创建分布式应用程序 13.4 创建应用程序服务器 13.5 创建客户端应用程序 13.6 在分布式应用程序中管理事务 13.7 支持远程数据模块的状态信息 13.8 用提供者组件和客户端交互 第14章 利用webbroker开发web应用 14.1 什么是webbroker 14.2 html基础 14.3 使用webbroker组件作开发 14.4 使用cookie 第15章 scket编程 15.1 winsock概述 15.2 服务端socket 15.3 客户端socket 15.4 数据传输 15.5 winsocd类组件介绍 15.6 如何创建自己的网络聊天室
C++语言程序设计
04-02
学习C++非常不错的入门工具书！可以夯实C++的基础知识！
c++应用编程200例
12-05
适合初学c++的朋友们，各种基础类型的程序，夯实基础！
参考-C++语言程序设计习题集
12-13
此C++语言程序设计习题集是一本较为实用的习题集，涵盖了面向过程部分，在面向对象习题的设计上难易适中，非常利于夯实基础，为进一步提高做好了铺垫，其中，指针这块的习题对于学习者来说是个很大的挑战和拔高。
C++高手开发集训营 C++从夯实基础到项目实例开发教程 C++精华开发专题课程
07-05
├─01_1_day1_课程内容介绍1.mp4 ├─02_2_day1_课程内容介绍2.mp4 ├─03_3_day1_职业发展.mp4 ├─04_4_day1_数据类型1.mp4 ├─05_5_day1_数据类型2.mp4 ├─06_6_day2_数据类型3.mp4 ├─07_7_day2_scanf原理讲解.mp4 ├─08_8_day2_运算符1.mp4 ├─09_9_day2_运算符2.mp4 ├─10_10_day2_运算符3.mp4 ├─11_11_day3_选择与循环1.mp4 ├─12_12_day3_选择与循环2.mp4 ├─13_13_day3_循环与一维数组.mp4 ├─14_14_day3_一维数组2.mp4 ├─15_15_day3_二维数组.mp4 ├─16_16_day3_字符数组.mp4 ├─17_17_day4_指针的传递.mp4 ├─18_18_day4_指针的偏移使用.mp4 ├─19_19_day4_指针传递与偏移的应用.mp4 ├─20_20_day4_数组指针与二维数组.mp4 ├─21_21_day4_题目讲解.mp4 ├─22_22_da
初级C++基础夯实
qq_43804905的博客
05-27 265
空间配置器：内存开辟/内存释放 对象构造/对象析构，以上四个内容都由空间配置器完成加上空间配置器。
夯实C++基础学习笔记
weixin_51368613的博客
11-23 718
夯实C++基础核心
夯实C++基础：1.C++生命周期和编程范式、预处理、编译相关
qq_37299596的博客
05-29 138
一直告诉自己要保持学习；；但真的工作之后，反而不知道从哪里开始学起，就这么拖着光有想法没有行动。除了加班没有那么晚刷刷题之外，就从看课有人带着学开始夯实基础吧，反正学啥都比不学好。之后可以看设计模式，网络编程，STL深入学一学，也可以看书effectiveC++，操作系统内核之类//////要保持学习呀！ C++ 程序的生命周期 四个阶段：编码、预处理、编译、运行 编码 预处理是C/C++独有的阶段，在这个阶段发挥作用的是预处理器Pre-process，输入是编码阶段产生的源码文件，输出是经过“预处.
C++ | 语句的基础知识(夯实基础)
weixin_72906726的博客
05-06 810
本篇文章主要介绍数据结构中**C++**的语句内容，适合有**零基础**的同学，文中描述和代码示例很详细，干货满满，感兴趣的小伙伴快来一起学习吧！
Java基础——夯实基础
qq_51936245的博客
05-06 439
New highlights in Java SE 8New highlights in Java SE 7Java SE 8 新特性 ​Java SE 8 引入了许多新特性，以下是其中的一些：Lambda 表达式：简化了代码编写，并支持函数式编程。流式 API：提供了一种更为简单、可读性更高的方式来处理集合数据。日期和时间 API：提供了一个新的日期和时间 API，使日期和时间处理更加简单。默认方法：允许接口在不破坏现有实现的情况下添加新方法。类型注解：增加了对代码中类型注解的支持。Nashhorn Ja
夯实C++基础之刷题：链表——相交链表
qq_37299596的博客
03-07 516
一点点进步计划：首先要坚持刷题，刷题是一个将思路用代码实现的过程；2要自己看知识点 平时也看看面经 这样才与时俱进//////-------先从每天能做一道题开始把 1、相交链表
夯实C++基础之刷题：链表——2链表反转
qq_37299596的博客
03-08 513
题目 题解 1、双指针 每一次都局部翻转 class Solution { public: ListNode* reverseList(ListNode* head) { ListNode* cur = NULL, *pre = head; while (pre != NULL) { ListNode* t = pre->next; pre->next = cur; cur = pr
夯实C++基础之刷题：10 用队列实现栈
qq_37299596的博客
05-15 137
题目 思路和代码 class MyStack { public: queue<int> q1; queue<int> q2; MyStack() { } //1 2 //元素是通过队列出来的，在队列2里元素依旧是先进先出的。而栈是需要后进的先出，那么2进队列前先让1出来。 就成了2在1前面。（这个固定了） 然后3再进来，就把前面部分继续先挪到后一个队列 //队列的特点是，固定部分元素进出顺序就不变了。12出在q2里也是12 回来依旧是12
夯实C++基础之刷题：链表——8 回文链表
qq_37299596的博客
05-09 73
题目 思路 第一反应是 从中间开始一一比较，那么用双指针走到中点，然后和头节点一一比较 为了锻炼代码能力，先写这个，其他赋值到数组，还有递归的都要写一写 方法1 快慢指针 慢指针一次走一步，快指针一次走两步，快慢指针同时出发。当快指针移动到链表的末尾时，慢指针到链表的中间。由此分为两部分。 ...
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++MFC基础实验感悟
06-09
作为一个AI，我没有感悟，但是我可以为您提供一些关于C++ MFC基础实验的建议。 在学习C++ MFC基础实验时，建议首先掌握面向对象编程的思想，理解类、对象、封装、继承、多态等概念。同时，要深入学习MFC框架的相关知识，掌握窗口、消息、控件、对话框、菜单等基本控件的使用方法。 在实践中，可以通过模仿已有的应用程序，如记事本、画图工具等，逐步熟悉MFC框架的使用方法和相关控件的属性和事件。同时，要注重代码的规范性和可读性，养成良好的编程习惯。 最后，要勤于思考和总结，在实践中不断积累经验，不断提高自己的编程水平。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值