C++基础_Day02

文章目录

• 四、流程控制语句
• • 4.1 选择结构
  • 4.1.2 三目运算符
  • 4.1.3 switch语句
  • 4.1.4 if和switch的区别【CHAT】
  • 4.2 循环结构
  • 4.2.3 for循环语句
  • 4.3 跳转语句
• 五、数组
• • 5.1 一维数组
  • 5.2 二维数组
• 六、函数

四、流程控制语句

顺序结构、选择结构、循环结构

4.1 选择结构

4.1.1 if语句

用于执行基于条件的代码块。

（1）.单行格式if语句：if(条件){ 条件满足执行的语句 }
if条件表达式后不要加分号

if (sum==100)
	{
	  cout<<"sum=="<<100<<endl;
	}

( 2 ) .多行格式if语句：

`if(条件){ 条件满足执行的语句 }
else{ 条件不满足执行的语句 };`

( 3 ).多行格式if语句：

`if(条件){ 条件满足执行的语句 }
else{ 条件不满足执行的语句 };`

4.1.2 三目运算符

语法：表达式1 ? 表达式2 ：表达式3

	int a = 10;
	int b = 20;

	int c = a > b ? a : b;
	cout << "c = " << c << endl;

4.1.3 switch语句

switch - case

每个case标签之后不会自动执行到下一个case标签，除非使用break语句来显式终止switch块。

switch(表达式)

{

	case 结果1：执行语句;break;

	case 结果2：执行语句;break;

	...

	default:执行语句;break;

}

举例代码：

#include <iostream>

int main() {
    int choice = 2;

    switch (choice) {
        case 1:
            std::cout << "选项1" << std::endl;
        case 2:
            std::cout << "选项2" << std::endl;
        case 3:
            std::cout << "选项3" << std::endl;
        default:
            std::cout << "默认选项" << std::endl;
    }

    return 0;
}

这是因为没有break语句来终止case标签，导致控制流“直通”到后续的case标签。如果您想要避免这种行为，应在每个case块的末尾使用break语句来显式退出switch块。

注意事项

1. switch语句中的表达式类型通常只能是整型或字符型。这是因为case标签中的常量值需要与表达式的类型匹配。

2. 如果在case标签中没有使用break语句，程序会继续执行下一个case标签，这就是所谓的“直通”行为。

3. switch语句在处理多个条件判断时具有结构清晰和执行效率高的优点。它适用于在一系列离散值中选择执行不同的代码块。

4. 一个switch语句的缺点是它不能直接判断区间，只能针对离散的值进行判断。要处理区间，通常需要使用一系列if语句或其他逻辑结构。

这些特点使switch成为一种适用于某些情况下的有效控制结构，但在其他情况下可能需要使用不同的条件控制方式。

4.1.4 if和switch的区别【CHAT】

`if`更灵活，适用于各种条件逻辑，
`switch`更适用于多个等值条件的情况下，代码更具可读性。

1. 用法：

   • if语句适用于任何条件判断，可以处理各种复杂的条件表达式，包括比较、逻辑运算等。它可以用来实现灵活的条件控制。
   • switch语句通常用于根据一个表达式的不同值来选择执行不同的代码块。它适用于多个等值条件的情况。

2. 条件：

   • if语句可以处理各种条件，包括布尔表达式、比较表达式、逻辑表达式等，可以实现更灵活的条件逻辑。
   • switch语句通常用于处理整数或字符类型的表达式，用于离散的值判断，而不适用于范围或其他类型的条件。

3. 多条件：

   • if语句可以轻松处理多个条件，通过嵌套if语句或使用else if来实现多个条件分支。
   • switch语句通过多个case标签来处理多个等值条件，通常更适用于处理相对简单的多条件情况。

4. 可读性：

   • switch语句通常在处理多个等值条件时更具可读性，因为所有条件都集中在一起。
   • if语句用于处理复杂的条件逻辑时可能需要更多的嵌套，可读性可能较差。

5. 执行流程：

   • if语句是根据条件的真假来决定是否执行某个代码块。
   • switch语句是基于表达式的值来选择执行哪个case块，然后执行该块内的代码，之后需要使用break语句来终止switch块，否则会"直通"到下一个case。

综上所述，选择使用if还是switch取决于您的需求。

4.2 循环结构

4.2.1 while循环语句

语法： while(循环条件){ 循环语句 }

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

执行循环语句时确实必须提供跳出循环的出口，否则可能会陷入死循环，导致程序永远不会停止执行。以下是一些常见的方法来实现循环的退出

4.2.2 do…while循环语句

语法： do{ 循环语句 } while(循环条件);
与while的区别在于do…while会先执行一次循环语句，再判断循环条件

4.2.3 for循环语句

语法： for(起始表达式;条件表达式;末尾循环体) { 循环语句; }
for循环中的表达式，要用分号进行分隔

九九乘法表

4.3 跳转语句

4.3.1 break语句

1. 在switch语句中：break语句用于终止当前的case标签块，并跳出switch语句。这可以防止"直通"到下一个case标签。

2. 在循环语句中（如for、while、do-while）：break语句用于提前跳出当前循环，即使循环条件仍然满足。它用于终止循环的执行，使程序流程进入循环后的下一个语句。

3. 在嵌套循环中：如果存在多个嵌套循环，break语句通常跳出最近的内层循环，而不是整个外层循环。这允许您有选择性地退出嵌套循环中的一个循环，而不必退出所有嵌套层次。

break语句是控制流的重要工具，用于在满足特定条件时改变程序的执行路径。要注意，滥用break可能会导致代码难以理解和维护，因此应该慎重使用。

4.3.2 continue语句

continue并没有使整个循环终止，而break会跳出循环

4.3.3 goto语句：- goto关键字。

语法： goto 标记;

`goto`语句是一种在编程中用来无条件跳转到程序中的标记（label）处的控制语句。

goto 标记;

• 标记是在程序中的一个标签，通常是一个带有冒号的标识符，例如 label:。

使用goto语句可以使程序跳转到指定标记的位置，继续执行代码。这可以在某些情况下用于实现特定的控制流程，但要小心使用，因为滥用goto可能导致程序难以理解和维护，产生不可预测的行为。

大多数现代编程语言鼓励避免使用goto，并提供更结构化的控制结构，如条件语句和循环，以更清晰和可维护的方式实现控制流程。在实际编程中，通常不需要使用goto，并且可以通过其他方法来实现相同的目标。

五、数组

（1）数据类型相同： 数组中的每个数据元素都必须是相同的数据类型。这意味着如果您创建一个整数数组，每个元素都必须是整数；如果是字符数组，每个元素都必须是字符，以此类推。

（2）连续内存： 数组的元素在内存中是连续存储的，这意味着数组中的元素在内存中相邻，没有额外的空间分隔它们。这也是数组的一个重要特点，因为它允许通过索引来快速访问元素，索引值可用于计算元素的内存地址。

5.1 一维数组

一维数组定义的三种方式：

1. 数据类型 数组名[ 数组长度 ];
2. 数据类型 数组名[ 数组长度 ] = { 值1，值2 ...};
3. 数据类型 数组名[ ] = { 值1，值2 ...};

（1）. 可以统计整个数组在内存中的长度sizeof(arr) / sizeof(arr[0])
（2）可以获取数组在内存中的首地址(int)arr

CLion中有错误：cast from ‘int*’ to ‘int’ loses precision [-fpermissive]问题解决

该这里是因为基于Linux内核的64位系统上指针类型占用8个字节，而int类型占用4个字节，所以会出现loses precision。

可以先将int* 转成long类型，long类型可以隐式类型转换到int类型。直接修改为long long即可

cout << "数组首地址为：" << (long long)arr << endl;  
cout << "数组第一个元素地址为：" << (long long)&arr[0] << endl;
cout << "数组第二个地址为：" << (long long)&arr[1] << endl;

冒泡排序

int main() {

	int arr[9] = { 1,7,5,3,4,8,6,2,3};

	for (int i = 0; i < 9 - 1; i++)
	{
		for (int j = 0; j < 9 - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}

	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << endl;
	}
    
	system("pause");

	return 0;
}

C语言内置的qsort

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

// 比较函数，用于告诉qsort如何比较元素
int compare(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    int length = sizeof(arr) / sizeof(arr[0]);

    // 使用qsort对整数数组进行升序排序
    qsort(arr, length, sizeof(int), compare);

    // 打印排序后的数组
    printf("排序后的数组：");
    for (int i = 0; i < length; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

5.2 二维数组

二维数组定义的四种方式：

1. 数据类型 数组名[ 行数 ][ 列数 ];
2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
3. 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
4. 数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};

六、函数

将一段经常使用的代码封装起来，减少重复代码

返回值类型 函数名 （参数列表）
{

       函数体语句

       return表达式

}

int add(int num1, int num2)
{
    //函数体语句
	int sum = num1 + num2;
    //return表达式
	return sum;
}

调用 函数名（参数）

int add(int num1, int num2) //定义中的num1,num2称为形式参数，简称形参（形参列表）
{
    int sum = num1 + num2;
    return sum;
}

int add(int num1, int num2, int num3) {
    int sum = num1 + num2 + num3;
    return sum;
}

int main() {

    int a = 10;
    int b = 10;
    //调用add函数
    int sum = add(a, b);//调用时的a，b称为实际参数，简称实参
    cout << "sum = " << sum << endl;

    int sum1 = add(a, b, 10);
    cout << "sum1 = " << sum1 << endl;

    a = 100;
    b = 100;

    sum = add(a, b);
    cout << "sum = " << sum << endl;

    system("pause");

    return 0;
}

值传递

值传递时，形参是修饰不了实参的

形参无论发生什么变化都不会影响实参

void swap(int num1, int num2)
{
	cout << "交换前：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "交换后：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

	//return ; 当函数声明时候，不需要返回值，可以不写return
}

int main() {

	int a = 10;
	int b = 20;

	swap(a, b);

	cout << "mian中的 a = " << a << endl;
	cout << "mian中的 b = " << b << endl;

	system("pause");

	return 0;
}

如果想要改变实参 – 互换地址的内容：

void swap(int num1, int num2)
{
    cout << "交换前：" << endl;
    cout << "num1 = " << num1 << endl;
    cout << "num2 = " << num2 << endl;
    cout << "&num1="<< &num1<<endl;
    cout << "&num2="<< &num1<<endl;


    int temp = num1;
    num1 = num2;
    num2 = temp;
    cout << "&temp="<<&temp<<endl;

    cout << "交换后：" << endl;
    cout << "num1 = " << num1 << endl;
    cout << "num2 = " << num2 << endl;
    cout << "&num1="<< &num1<<endl;
    cout << "&num2="<< &num1<<endl;

    //return ; 当函数声明时候，不需要返回值，可以不写return
}

int main() {

    int a = 10;
    int b = 20;

    swap(a, b);

    cout << "mian中的 a = " << a << endl;
    cout << "mian中的 b = " << b << endl;
    cout << "&a="<< &a<<endl;
    cout << "&b="<< &b<<endl;
    system("pause");

    return 0;
}