C++跑步入门笔记4- 函数、指针、结构体

2023-03-21 本文已影响0人布拉德澈

一、函数

1.1 概述

作用：将一段经常使用的代码封装起来，减少重复代码
一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

1.2 函数的定义

函数的定义一般主要有5个步骤：

1、返回值类型
2、函数名
3、参数表列
4、函数体语句
5、return 表达式

语法：

返回值类型 函数名 （参数列表）
{
       函数体语句
       return 表达式
}

返回值类型：一个函数可以返回一个值。在函数定义中
函数名：给函数起个名称
参数列表：使用该函数时，传入的数据
函数体语句：花括号内的代码，函数内需要执行的语句
return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据

示例：定义一个加法函数，实现两个数相加

//函数定义
int add(int num1, int num2){
    int sum = num1 + num2;
    return sum;
}

1.3 函数的调用

功能：使用定义好的函数
语法：函数名（参数）
示例：

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

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

    a = 100;
    b = 100;

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

    system("pause");
    return 0;
}

总结：函数定义里小括号内称为形参，函数调用时传入的参数称为实参

1.4 值传递

所谓值传递，就是函数调用时实参将数值传入给形参
值传递时，==如果形参发生，并不会影响实参==

示例：

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;
}

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

1.5 函数的常见样式

常见的函数样式有4种

无参无返
有参无返
无参有返
有参有返

示例：

//函数常见样式
//1、 无参无返
void fun01(){
    //void a = 10; //无类型不可以创建变量,原因无法分配内存
    cout << "this is test01" << endl;
    //test01(); 函数调用
}

//2、 有参无返
void fun02(int a){
    cout << "this is test02" << endl;
    cout << "a = " << a << endl;
}

//3、无参有返
int fun03(){
    cout << "this is test03 " << endl;
    return 10;
}

//4、有参有返
int test04(int a, int b){
    cout << "this is test04 " << endl;
    int sum = a + b;
    return sum;
}

1.6 函数的声明

作用： 告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。

函数的声明可以多次，但是函数的定义只能有一次
示例：

//声明可以多次，定义只能一次
//声明
int max(int a, int b);
int max(int a, int b);

int main() {
    int a = 100;
    int b = 200;
    cout << max(a, b) << endl;
    system("pause");
    return 0;
}
//定义
int max(int a, int b){
    return a > b ? a : b;
}

1.7 函数的分文件编写

作用：让代码结构更加清晰

函数分文件编写一般有4个步骤

创建后缀名为.h的头文件
创建后缀名为.cpp的源文件
在头文件中写函数的声明
在源文件中写函数的定义

示例：

//swap.h文件
#include<iostream>
using namespace std;

//实现两个数字交换的函数声明
void swap(int a, int b);

//swap.cpp文件
#include "swap.h"

void swap(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
}

//main函数文件
#include "swap.h"
int main() {
    int a = 100;
    int b = 200;
    swap(a, b);

    system("pause");
    return 0;
}

二、指针

2.1 指针的基本概念

指针的作用： 可以通过指针间接访问内存

内存编号是从0开始记录的，一般用十六进制数字表示
可以利用指针变量保存地址

2.2 指针变量的定义和使用

指针变量定义语法： 数据类型 * 变量名；
示例：

int main() {

    //1、指针的定义
    int a = 10; //定义整型变量a
    
    //指针定义语法： 数据类型 * 变量名 ;
    int * p;

    //指针变量赋值
    p = &a; //指针指向变量a的地址
    cout << &a << endl; //打印数据a的地址
    cout << p << endl;  //打印指针变量p

    //2、指针的使用
    //通过*操作指针变量指向的内存
    cout << "*p = " << *p << endl;

    system("pause");

    return 0;
}

指针变量和普通变量的区别

普通变量存放的是数据,指针变量存放的是地址
指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用

总结1：我们可以通过 & 符号获取变量的地址
总结2：利用指针可以记录地址
总结3：对指针变量解引用，可以操作指针指向的内存

2.3 指针所占内存空间

提问：指针也是种数据类型，那么这种数据类型占用多少内存空间？
示例：

int main() {
    int a = 10;
    int * p;
    p = &a; //指针指向数据a的地址

    cout << *p << endl; //* 解引用
    cout << sizeof(p) << endl;
    cout << sizeof(char *) << endl;
    cout << sizeof(float *) << endl;
    cout << sizeof(double *) << endl;

    system("pause");
    return 0;
}

总结：所有指针类型在32位操作系统下是4个字节

2.4 空指针和野指针

空指针：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的

示例1：空指针

int main() {
    //指针变量p指向内存地址编号为0的空间
    int * p = NULL;

    //访问空指针报错 
    //内存编号0 ~255为系统占用内存，不允许用户访问
    cout << *p << endl;

    system("pause");
    return 0;
}

野指针：指针变量指向非法的内存空间
示例2：野指针

int main() {

    //指针变量p指向内存地址编号为0x1100的空间
    int * p = (int *)0x1100;
    //访问野指针报错 
    cout << *p << endl;
    system("pause");
    return 0;
}

总结：空指针和野指针都不是我们申请的空间，因此不要访问。

2.5 const修饰指针

const修饰指针有三种情况

const修饰指针 --- 常量指针

指针的指向可以修改，但指针指向的值不可以修改。

const修饰常量 --- 指针常量

const修饰的是常量，指针指向不可以改，指针指向的值可以更改

const即修饰指针，又修饰常量

示例：

int main() {

    int a = 10;
    int b = 10;

    //const修饰的是指针，指针指向可以改，指针指向的值不可以更改
    const int * p1 = &a; 
    p1 = &b; //正确
    //*p1 = 100;  报错
    

    //const修饰的是常量，指针指向不可以改，指针指向的值可以更改
    int * const p2 = &a;
    //p2 = &b; //错误
    *p2 = 100; //正确

    //const既修饰指针又修饰常量
    const int * const p3 = &a;
    //p3 = &b; //错误
    //*p3 = 100; //错误

    system("pause");

    return 0;
}

技巧：看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量

2.6 指针和数组

作用：利用指针访问数组中元素
示例：

int main() {
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    int * p = arr;  //指向数组的指针

    cout << "第一个元素： " << arr[0] << endl;
    cout << "指针访问第一个元素： " << *p << endl;

    p++;
    cout << " 利用指针访问第2个元素:" << *p << endl;
    
    //用指针遍历数组元素
    int* p2 = arr;
    for (int i  = 0; i< 10;i++) {
        cout << " 利用指针访问第"<< i << "元素:" << *p2 << endl;
        p2++;
    }
    system("pause");
    return 0;
}

2.7 指针和函数

作用：利用指针作函数参数，可以修改实参的值

//值传递
void swap1(int a ,int b){
    int temp = a;
    a = b; 
    b = temp;
}
//地址传递
void swap2(int * p1, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

int main() {
    int a = 10;
    int b = 20;
    swap1(a, b); // 值传递不会改变实参
    swap2(&a, &b); //地址传递会改变实参

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    system("pause");
    return 0;
}

总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递

2.8 指针、数组、函数

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序
例如数组：int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };

//冒泡排序函数
void bubbleSort(int * arr, int len)  //int * arr 也可以写为int arr[]
{
    for (int i = 0; i < len - 1; i++){
        for (int j = 0; j < len - 1 - i; j++){
            if (arr[j] > arr[j + 1]){
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

//打印数组函数
void printArray(int arr[], int len){
    for (int i = 0; i < len; i++){
        cout << arr[i] << endl;
    }
}

int main() {
    int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
    int len = sizeof(arr) / sizeof(int);

    bubbleSort(arr, len);
    printArray(arr, len);

    system("pause");
    return 0;
}

总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针

三、结构体

3.1 结构体基本概念

结构体属于用户【自定义的数据类型】，允许用户存储不同的数据类型

3.2 结构体定义和使用

语法：struct 结构体名 { 结构体成员列表 }；
通过结构体创建变量的方式有三种：

struct 结构体名变量名
struct 结构体名变量名 = { 成员1值，成员2值...}
定义结构体时顺便创建变量

//结构体定义
struct student{
    //成员列表
    string name;  //姓名
    int age;      //年龄
    int score;    //分数
}stu3; //结构体变量创建方式3 

int main() {
    //结构体变量创建方式1
    struct student stu1; //struct 关键字可以省略
    stu1.name = "张三";
    stu1.age = 18;
    stu1.score = 100;
    
    cout << "姓名：" << stu1.name << " 年龄：" << stu1.age  << " 分数：" << stu1.score << endl;

    //结构体变量创建方式2
    struct student stu2 = { "李四",19,60 };

    cout << "姓名：" << stu2.name << " 年龄：" << stu2.age  << " 分数：" << stu2.score << endl;
    stu3.name = "王五";
    stu3.age = 18;
    stu3.score = 80;
    cout << "姓名：" << stu3.name << " 年龄：" << stu3.age  << " 分数：" << stu3.score << endl;

    system("pause");
    return 0;
}

总结1：定义结构体时的关键字是struct，不可省略
总结2：创建结构体变量时，关键字struct可以省略
总结3：结构体变量利用操作符 ''.'' 访问成员

3.3 结构体数组

作用：将自定义的结构体放入到数组中方便维护
语法：struct 结构体名数组名[元素个数] = { {} , {} , ... {} }

//结构体定义
struct student{
    //成员列表
    string name;  //姓名
    int age;      //年龄
    int score;    //分数
}

int main() {
    //结构体数组
    struct student arr[3]={
        {"张三",18,80 },
        {"李四",19,60 },
        {"王五",20,70 }
    };
    for (int i = 0; i < 3; i++){
        cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << " 分数：" << arr[i].score << endl;
    }

    system("pause");
    return 0;
}

3.4 结构体指针

作用：通过指针访问结构体中的成员

利用操作符 ->可以通过结构体指针访问结构体属性
示例：

//结构体定义
struct student{
    //成员列表
    string name;  //姓名
    int age;      //年龄
    int score;    //分数
};

int main() {
    
    struct student stu = { "张三",18,100, };
    struct student * p = &stu;
    p->score = 80; //指针通过 -> 操作符可以访问成员
    cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
    
    system("pause");
    return 0;
}

总结：结构体指针可以通过 -> 操作符来访问结构体中的成员

C++跑步入门笔记4- 函数、指针、结构体

一、函数

1.1 概述

1.2 函数的定义

1.3 函数的调用

1.4 值传递

1.5 函数的常见样式

1.6 函数的声明

1.7 函数的分文件编写

二、指针

2.1 指针的基本概念

2.2 指针变量的定义和使用

2.3 指针所占内存空间

2.4 空指针和野指针

2.5 const修饰指针

2.6 指针和数组

2.7 指针和函数

2.8 指针、数组、函数

三、结构体

3.1 结构体基本概念

3.2 结构体定义和使用

3.3 结构体数组

3.4 结构体指针

猜你喜欢

热点阅读

C++跑步入门笔记4- 函数、指针、结构体

一、函数

1.1 概述

1.2 函数的定义

1.3 函数的调用

1.4 值传递

1.5 函数的常见样式

1.6 函数的声明

1.7 函数的分文件编写

二、 指针

2.1 指针的基本概念

2.2 指针变量的定义和使用

2.3 指针所占内存空间

2.4 空指针和野指针

2.5 const修饰指针

2.6 指针和数组

2.7 指针和函数

2.8 指针、数组、函数

三、结构体

3.1 结构体基本概念

3.2 结构体定义和使用

3.3 结构体数组

3.4 结构体指针

猜你喜欢

热点阅读

二、指针