学完C之后迈向C++-CSDN博客

本文链接：https://blog.csdn.net/D13924691277/article/details/127239986

整理笔记

C++判断

if判断语句：由一个布尔表达式后跟一个或多个语句组成
if(boolean_expression)
{
    //如果布尔表达式为真将执行的语句
}

if..else判断语句：else语句是布尔表达式为假时执行
if(boolean_expression)
{
    //如果布尔表达式为真将执行的语句
}
else
{
    //如果布尔表达式为假将执行的语句
}
当使用if...else if...else语句时应注意以下几点

一个if后可跟零个或一个else，else必须在else if之后
一个if后可跟零个或多个else if，else if 必须在else之前
一旦某个else if匹配成功，其他else if 或else将不会被执行

C++中的if...else if...else语句的语法：
if(boolean_expression 1)
{
    //当布尔表达式 1 为真将执行的语句
}
else if(boolean_expression 2)
{
    //当布尔表达式 2 为真将执行的语句
}
else if(boolean_expression 3)
{
    //当布尔表达式 3 为真将执行的语句
}
else
{
    //当上面表达式都为假是执行
}

switch判断语句：一个switch语句允许测试一个变量等于多个值的情况，每一个情况的值为一个case，且被测试的变量会对每个switch case进行检查。
switch(expression){
    case constant-expression 1 :
        statement(s);
        break;
    case constant-expression 2:
        statement(s);
        break;

     //可以有任意多的case语句
     default : //可选的
        statement(s);
}
switch语句规则 ：

switch语句中的expression必须是一个整型或者枚举类型，或者是一个class类型，其中class由一个单一的转换函数将其转换为整型或枚举类型。
在一个switch中可以有任意多的case语句，且在每个case后都要跟一个比较的值和一个冒号。
case的constant-expression必须与switch中的变量具有相同的数据类型，且必须是一个常量和字面量。
被测试的变量等于case中的常量时，case后的语句被执行，至break语句为止，switch语句结束。
每一个case后都不一定需要有break语句，当遇到不包含break的case语句时，控制流会继续后续的case语句直到遇见break。
一个switch语句可以有一个可选的default case在结尾，可用于上面的case语句都为假时执。

switch语句的嵌套语法:

switch(ch1){
    case 'A' :
        cout << "这个 A 是外部 switch 的一部分";
        switch(ch2){
            case ' A ' :
                cout << "这个 A 是内部 switch 的一部分"
                break;
            case ' B ' :
                cout << "这个 b 是内部 switch 的一部分"
            }
            break;
    case ' B ':
        cout << "这个 B 是外部 switch 的一部分";
}

C++函数定义

一般形式如下：

return_type funtion_name( parameter list )
{
    body of the function;
}

在C++中，函数由一个函数头和一个函数主体组成，下面列出一个函数的所有组成部分：

返回类型：一个函数可以返回一个值。return_type是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，这种情况下，return_type是关键字void。

函数名称：这是函数的实际名称。函数吗和参数列表一起构成了函数名。

参数：参数就像是占位符。当函数被调用时。向参数传递一个值，这个值被称为实际参数。参数列表包括函数的类型、顺序、数量。参数是可选的，函数可能不包含参数。

函数主体：函数主体包含一组定义函数执行任务的语句。

以下是定义max()函数的实例：

int max(int num1, int num2)
{
    int result;
    if(num1 > num2)
        result = num1;
    else
        result = num2;
    return result;
}

函数声明：声明时会告诉编译器函数名称以及如何调用函数。

函数的实际主体可以单独定义。

return_type function_name(parameter list);

调用函数：当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行定义的一任务，当函数的返回语句被执行时，或达到函数的结束括号时，会把程序控制权交还给主程序。

调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值

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

int main(){
	int a = 100;
	int b = 200;
	int ret;

	ret = max(a,b);//调用函数来获取最大值
	
	cout << "Max value is :" << ret <<endl;
	
	return 0;
}
int max(int num1, int num2)
{
    int result;
    if(num1 > num2)
        result = num1;
    else
        result = num2;
    return result;
}

函数参数：函数要使用参数时，就必须声明接收参数值的变量。称为形式参数，形式参数在进入函数时被创建，退出函数时被销毁。

调用函数的方式：

传值调用：把参数的实际值赋值给函数的形式参数，修改函数内的形式参数对实际的函数没有影响。

#include<iostream.h>
using namespace std;
void swap(int x, int y);//函数声明

int main(){
	int a = 100;
	int b = 200;
	
	cout << "交换前，a的值：" << a <<endl;

	cout << "交换前，b的值：" << b <<endl;

	swap(a,b)
	return 0;
}
void swap(int x, int y)
{
    int temp;
	temp = x; //保存x的值
	x = y;	  //y的值赋给x
	y = temp; //x的值赋给y
    return ;
}

指针调用：把参数的地址复制给形式参数，在函数内，该地址用于访问调用中要用到的实际参数，修改形式参数会影响实际参数。

#include<iostream.h>
using namespace std;
void swap(int *x, int *y);//函数声明

int main(){
	int a = 100;
	int b = 200;
	
	cout << "交换前，a的值：" << a <<endl;

	cout << "交换前，b的值：" << b <<endl;

    //&a和&b表示指向a和b的指针，表示的是a和b的地址
	swap(&a,&b)

	return 0;
}
void swap(int x, int y)
{
    int temp;
	temp = *x;     //保存*x的值
	*x = *y;	   //*y的值赋给*x
	*y = temp;     //*x的值赋给*y
    return ;
}

引用调用：把参数的地址复制给形式参数，在函数中，引用用于访问调用中要用到的实际参数，修改形式参数会影响实际参数

按引用传递值，参数引用被传递给函数，就像传递其他值给函数一样，在swap() 函数中，需要什么函数参数为引用类型，
#include<iostream.h>
using namespace std;
void swap(int &x, int &y);//函数声明

int main(){
	int a = 100;
	int b = 200;
	
	cout << "交换前，a的值：" << a <<endl;

	cout << "交换前，b的值：" << b <<endl;

	swap(a,b)
	return 0;
}
void swap(int x, int y)
{
    int temp;
	temp = x; //保存x的值
	x = y;	  //y的值赋给x
	y = temp; //x的值赋给y
    return ;
}

当定义了一个函数时，可以为参数列表后面的每一个参数指定默认值，当调用函数时，如果实际参数的值留空，则使用这个默认值。这是通过函数定义是使用赋值运算符来为参数赋值。调用函数时，如果未传递参数的值，则会使用默认值，如果指定了值，则会忽略默认值，使用传递的值：
#include<iostream.h>
using namespace std;

int sum(int a, int b=20){
    int result;
    result = a + b;
    result (result);
}


int main(){
	int a = 100;
	int b = 200;
	int result;
    result = sum(a,b);

	cout << "Total value is :" << result <<endl;
	cout << "Total value is ：" << result <<endl;
	return 0;
}