学习c++（从入门到入土第三天）

程序流程结构

跳转语句

break

#include <iostream>
using namespace std;
int main() {
    //break跳出选择结构和循环结构
    //循环语句：跳出当前循环语句       嵌套循环：跳出最近的内层循环语句      用于wsitch语句中，终止当前case语句并跳出switch
    int a;
    cin>>a;
    switch(a)
    {
        case 1:
            cout<<"100"<<endl;
            break;  //跳出当前case语句
        case 2:
            cout<<"60"<<endl;
            break;
        default:
            cout<<"0"<<endl;
            break;
    }
    int i=1;
    while(i<10)
    {
        cout<<i<<endl;
        i++;
        if(i>5)
        {
            break;  //跳出当前循环语句
        }
    }
    for(int i=0;i<10;i++)
    {
        for(int j=0;j<10;j++)
        {
            if(j==4)
            {
                break;  //当j=4时，跳出内层循环，继续外层循环
            }
            cout<<j;
        }
        cout<<endl;
    }
    return 0;
}

continue

#include <iostream>
using namespace std;
int main() {
    //continue语句：跳过本次循环中尚未执行的语句，继续执行下次循环
    //输出0-30，如果可以整除5，则不输出
    for(int i=0;i<=30;i++)
    {
        if (i%5==0)
        {
            continue;   //当i可以整除5时，跳过本次循环，不输出
        }
        cout<<i<<endl;
    }
    return 0;
}

goto语句

#include <iostream>
using namespace std;
int main() {
    //goto 可以无条件跳转语句    语法：goto 标记;
    //如果标记的名称存在，当执行到goto语句时，会跳转到标记的位置
    cout<<"1"<<endl;
    cout<<"2"<<endl;
    goto flag;
    cout<<"3"<<endl;
    cout<<"4"<<endl;
    cout<<"5"<<endl;
    flag:       //直接跳转到输出6，跳过3 4 5的输出
    cout<<"6"<<endl;
    cout<<"7"<<endl;
    return 0;
}

数组

一维数组

一维数组定义方式

#include <iostream>
using namespace std;
int main() {
    //一维数组的定义
    //三种定义方式
    // 1、数据类型  数组名[数据长度];
    // 2、数据类型  数组名[数据长度]={值1，值2，值3......};
    // 3、数据类型  数组名[]={值1，值2，值3......};
    //特点：数组中每个元素都是相同的数据类型，数组是由连续的内存位置组成的
    int arr1[5];
    for(int i=0;i<5;i++)
    {
        cin>>arr1[i];
    }
    int arr2[5]={10,20,30,40,50};
    for(int j=0;j<5;j++)
    {
        cout<<arr2[j]<<" ";
    }
    cout<<endl;
    int arr3[]={10,20,30,40,50};
    for(int k=0;k<5;k++)
    {
        cout<<arr3[k]<<" ";
    }
    return 0;
}

数组名

可以获取数组在内存中的首地址

可以统计整个数组在内存中的长度

#include <iostream>
using namespace std;
int main() {
    int arr1[]={10,20,30,40,50};
    cout<<sizeof(arr1)<<endl;//数组长度
    cout<<sizeof(arr1[1])<<endl;//数组中每个元素的长度
    cout<<sizeof(arr1)/sizeof(arr1[1])<<endl;//元素个数
    cout<<arr1<<endl;//输出arr1数组的首地址
    cout<<(long long)arr1<<endl;//将首地址转为十进制，int数据长度太短要使用long long
    cout<<(long long)&arr1[1]<<endl;//输出数组中第二个元素的地址
    //数组名是常量，不可以进行赋值操作
    return 0;
}

冒泡排序 

#include <iostream>
using namespace std;
//实现冒泡排序
int main() {
    int arr[9] = {20, 25, 30, 65, 98, 45, 75, 52, 37};//定义一个数组
    int a=sizeof(arr) / sizeof(arr[0]);//求出数组中元素个数
    for (int i = 0; i < a - 1; i++)//写循环对数组中元素进行冒泡排序，外层循环是要进行排序的轮次为：i=元素个数-1
    {
        for(int j=0;j<a-i-1;j++)//内层函数为每一轮排序要进行比较的次数，比较次数为：j=元素个数-排序轮数-1
        {
            if(arr[j]>arr[j+1])//判断要进行比较的两个数的大小
            {
                //如果前一个数大于后一个数则将进行判断的两个数字交换位置
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
    //将排序后的数组进行输出验证结果
    for(int k=0;k<a;k++)
    {
        cout<<arr[k]<<" ";
    }
    return 0;
}

二维数组

二维数组定义方式

#include <iostream>
using namespace std;
//二维数组的定义
int main() {
    /*
     二维数组的定义方式
     数据类型   数组名[行数][列数];
     数据类型   数组名[行数][列数]={{元素1},{元素2},{元素3}};
     数据类型   数组名[行数][列数]={元素1,元素2,元素3};
     数据类型   数组名[][列数]={元素1,元素2,元素3};
     定义时如果初始化了数组中元素，可以不写行数，但是列数必须要写，推荐使用第二种定义方式
     */
    int arr[3][3];
    int arr1[3][3]=
            {
                    {1,2,3},
                    {2,3,4},
                    {3,4,5}
            };
    int arr2[3][3]={1,2,3,4,5,6};
    int arr3[][3]={1,2,3,4,5,6,};
    //未初始化的部分自动初始化为0
    //写嵌套循环将二维数组进行输出，外层函数表示行数，内层函数表示列数
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            cout<<arr2[i][j]<<" ";
        }
        cout << endl;
    }
    return 0;
}

二维数组的数组名

#include <iostream>
using namespace std;
/*
 数组名:
  获取数组首地址
  获取数组所占内存长度
*/
int main() {
    int arr[3][3]={};
    //获取地址
    cout<<(long long)arr<<endl;     //获取数组首地址
    cout<<(long long)arr[1]<<endl;  //获取数组第二行的首地址
    //获取长度
    cout<<sizeof(arr)<<endl;        //整个数组在内存中长度
    cout<<sizeof(arr[0])<<endl;     //数组第一行在内存中所占长度
    cout<<sizeof(arr[0][0])<<endl;  //数组中一个元素所占长度
    return 0;
}

函数

函数的定义

#include <iostream>
using namespace std;
//函数的定义
/*
 返回值类型  函数名（参数列表）   形参
 {
    函数体;
    return ;
 }
 */
int add(int num1,int num2)
{
    int sum1=10;
    int sum2=20;
    int sum=num1+num2;
    return sum;
}
int main() {

    return 0;
}

函数的调用

#include <iostream>
using namespace std;
//函数调用      函数名(参数)
//定义方法，求两个数之和并将求出的结果返回
int add(int num1,int num2)
{
    int sum =num1+num2;
    return sum;
}
int main() {
    int a=10;
    int b=20;
    //调用方法输出结果
    int sum=add(a,b);
    cout<<sum<<endl;
    return 0;
}

值传递

#include <iostream>
using namespace std;
//值传递，实参将值传递给形参，形参发生改变不会影响到实参
//两个数进行交换   不需要返回值时使用void
void change(int num1,int num2)
{
    int temp;
    temp=num1;
    num1=num2;
    num2=temp;
    cout<<num1<<" "<<num2<<endl;
    //return ;
}
int main() {
    int a=10;
    int b=20;
    change(a,b);
    cout<<"实参的值:"<<endl;
    cout<<a<<" "<<b<<endl;
    return 0;
}

常见样式

#include <iostream>
using namespace std;
//函数的常见样式   1、无参无返  2、无参有返  3、有参无返  4、有参有返
void test01()
{
    cout<<"wucanwufan"<<endl;
}
int  test02()
{
    return 100;
}
void test03(int num1,int num2)
{
    int temp=num1;
    num1=num2;
    num2=temp;
    cout<<num1<<" "<<num2<<endl;
}
int test04(int num1,int num2)
{
    int sum=num1+num2;
    return sum;
}
int main() {
    cout<<"无参无返"<<endl;
    test01();
    cout<<"无参有返"<<endl;
    int a=test02();
    cout<<a<<endl;
    cout<<"有参无返"<<endl;
    test03(10,20);
    cout<<"有参有返"<<endl;
    int sum=test04(10,30);
    cout<<sum<<endl;
    return 0;
}

函数声明

#include <iostream>
using namespace std;
//函数声明  返回值类型   函数名（参数列表）   由于程序自上而下执行，因此若函数写在main函数之后时需要声明，写在main函数之前则不需要声明
int add(int num1,int num2);     //向系统声明存在一个函数名为add，使其在运行时不会报错

int main() {
    int a=10;
    int b=20;
    int sum=add(a,b);
    cout<<sum<<endl;
    return 0;
}

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

函数分文件编写

函数的分文件编写：

1. 创建后缀名为.h的头文件
2. 创建后缀名为.cpp的源文件
3. 在头文件中声明函数，并添加需要用到的头文件
4. 在源文件中定义函数，包含创建的头文件，使用双引号" "
5. 在需要用到创建的函数的文件中包含创建的头文件

#include "add.h"
int add(int num1,int num2)
{
    int sum=num1+num2;
    return sum;
}

#include <iostream>
int add(int num1,int num2);

#include <iostream>
using namespace std;
#include "add.h"

int main() {
    int sum=add(10,20);
    cout << sum << endl;
    return 0;
}