[黑马程序员课程记录]C++基础部分3

于 2022-09-30 14:34:30 发布
阅读量541 收藏
点赞数
分类专栏： C++之基础 文章标签： c++ 开发语言 visual studio 学习方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53953432/article/details/127122960
版权

第十一节课 函数

1.1 概述

 

1.2 函数定义

 

语法：

 

范例:

 

#include <iostream>
using namespace std;
​
int add(int num1, int num2)
{
    int sum = num1 + num2;
    return sum;
}
​
int main()
{
    system("pause");
    return 0;
}

1.3 函数调用

#include <iostream>
using namespace std;
​
int add(int num1, int num2)//加法函数
{
    int sum = num1 + num2;//函数定义时候，num1和num2没有具体数，只是一个形式上的参数，简称形参
    return sum;
}
​
int main()
{
    //main函数中调用add
    int a = 9;
    int b = 88;
​
    //函数调用语法：函数名称（参数）
    //a和b称为 实际参数，简称实参
    //调用的时候，实参的值会传递给形参
    int c=add(a, b);
    cout << c << endl;
​
    system("pause");
    return 0;
}

1.4 值传递

①所谓值传递，就是函数调用的时实参将数值传递给了形参

②值传递的时候，如果形参发生变化，并不会影响实参

 

#include <iostream>
using namespace std;
​
//值传递
//定义函数，实现两个数字交换
​
//如果函数不需要返回值，声明的时候可以用void
void exchange(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;
}
int main()
{
    int a = 199;
    int b = 188;
​
    cout << "a=" << a << endl;//199
    cout << "b=" << b << endl;//188
​
    //当我们做值传递的时候，函数形参发生变化，并不影响实参
    exchange(a, b) ;
    cout << "a=" << a << endl;//199
    cout << "b=" << b << endl;//188
​
    system("pause");
    return 0;
}

1.5 函数样式

 

#include <iostream>
using namespace std;
​
//1.无参无返
void test1()
{
    cout << "this is test1" << endl;
​
}
//2.有参无返
​
void test2(int a)
{
    cout << "this is test2 a=" << a << endl;
}
//3.无参有返
int test3()
{
    cout << "this is test3   " ;
    return 1000;
}
//4.有参有返
int test4(int a)
{
    cout << "this is test4 a="<< a  << endl;
    return a;
}
​
int main()
{
    test1();
​
    test2(100);
​
    int num1 = test3();
    cout << num1 << endl;
​
    test4(999);
​
    system("pause");
    return 0;
}

1.6 函数的声明

#include <iostream>
using namespace std;
​
//函数的声明
//比较函数 实现两个整型数字进行比较，返回
​
//声明
int max(int a, int b);//可以写多次，但是定义只能写一次
int max(int a, int b);
int max(int a, int b);
​
​
​
//int max(int a, int b)//定义只能写一次
//{
//  return a > b ? a : b;
//
//}
int main()
{
    int a = 10;
    int b = 20;
    cout << "较大的数是" << max(a, b) << endl;
​
    system("pause");
    return 0;
}
​
//定义//放main前面不用声明，放main后面要声明
int max(int a, int b)
{
    return a > b ? a: b;
​
}

1.7函数的分文件编写

 

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

主函数.cpp

#include <iostream>
using namespace std;
#include "swap.h" 
//""是用于搜索所有目录即自定义的头文件，<>是用于搜索当前目录即系统提供的头文件如库函数。
​
​
int main()
{
    int a = 10;
    int b = 100;
    swap(a, b);
​
    system("pause");
    return 0;
}
​

第十二节课 指针

1.1指针基本概念

 

1.2指针变量的定义和使用

语法：数据类型 * 变量名；

#include <iostream>
using namespace std;
​
​
int main()
{
    //定义指针
    int a = 10;
    
    //指针定义语法 ： 数据类型* 指针变量名
    int * p;
    
    //让指针记录a的地址
    p = &a;
    cout << "a的地址：" << &a << endl;
    cout << "指针p的地址：" << p << endl;
​
    //使用指针
    //可以通过解引用的方式来找到指针指向的内存
    //指针前加*代表解引用，找到指针指向的内存中的数据
    *p = 1000;
    cout << "a=" << a << endl;
    cout << "*p=" << *p << endl;
​
    system("pause");
    return 0;
}
​

1.3指针所占的内存空间

在32位操作系统，占4个空间大小

在64位操作系统，占8个空间大小

#include <iostream>
using namespace std;
​
​
int main()
{
    //指针所占内存大小
    int a = 10;
    int * p = &a;
​
    //在32位操作系统下，指针占4个空间，不管什么数据类型
    //在64位操作系统下，指针占8个空间
    cout << "sizeof (int*) = " << sizeof(p) << endl;//可以int *也可以p
    cout << "sizeof (int*) = " << sizeof(float *) << endl;
    cout << "sizeof (int*) = " << sizeof(long *) << endl;
    cout << "sizeof (int*) = " << sizeof(long long *) << endl;
​
    system("pause");
    return 0;
}
​

1.4空指针和野指针

 

#include <iostream>
using namespace std;
​
​
int main()
{
    //空指针
    //空指针用于给指针变量进行初始话访问的
    int* p = NULL;
​
​
    //空指针是不可以访问的
    //0~255之间存在的编号是系统占用的，不可以访问
    *p = 100;
​
    system("pause");
    return 0;
}

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

#include <iostream>
using namespace std;
​
​
int main()
{
    //野指针
    //在程序中要避免野指针
​
    int* p = (int*)0x1100;
    
    cout << *p << endl;//会报错
​
    system("pause");
    return 0;
}

1.5 const 修饰指针

 

 

 

 

#include <iostream>
using namespace std;
​
​
int main()
{
    //const 修饰指针
    int a = 10;
    int b = 10;
​
    const int* p = &a;
    //*p = 20;指向的值不能改
    p = &b;//指向可以改
​
    //const 修饰常量
    int * const  p2 = &a;
    *p2 = 100;//指针值可以改
    //p2 = &b;指向不能改
    
    //const 修饰指针和常量
    const int* const p3 = &a;
    //p3=&b；指针指向不能改
    //*p3=1000;指针值不能改
​
    system("pause");
    return 0;
}

1.6 指针与数组

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

#include <iostream>
using namespace std;
​
int main()
{
    //指针与数组
    //利用指针访问数组中的元素
​
    int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
    cout << "第一个元素是" << arr[0] << endl;
​
    int* p = arr;//数组名就是数组的首地址
    cout << "利用指针指向的第一个元素是" << *p << endl;
    p++;//指针向后偏移4个字节，因为int是4个字节
    cout << "利用指针指向的第二个元素是" << *p << endl;
    
    //利用指针遍历所有数组
    int* p2 = arr;
    for (int i = 1; i <= 10; i++)
    {
        cout << "利用指针指向的第"<<i<<"个元素是" << *p2 << endl;
        p2++;
​
    }
​
    system("pause");
    return 0;
}

1.7指针与函数

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

#include <iostream>
using namespace std;
​
void swap1(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
    cout << "swap1中a=" << a << endl;
    cout << "swap1中b=" << b << endl;
}
void swap2(int *p1, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
    cout << "swap2中a=" << *p1 << endl;
    cout << "swap2中b=" << *p2 << endl;
​
}
​
int main()
{
    //指针与函数
    //1.值传递
​
    int a = 10;
    int b = 99;
    swap1(a, b);
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
​
    //地址传递
    swap2(&a, &b);//会改变实参的值
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
​
    system("pause");
    return 0;
}

1.8 指针，数组，函数一起的案例练习

 

#include <iostream>
using namespace std;
​
void sort(int* p,int L)
{
    for (int i = 0; i < L; i++)
    {
        for (int j = 1; j < L-i; j++)
        {
            if (p[j] < p[j - 1])
            {
                int temp = p[j];
                p[j ] = p[j-1];
                p[j - 1] = temp;
            }
        }
    }
    for (int k = 0; k < L; k++)
    {
        cout << p[k] << endl;
    }
}
​
int main()
{
    int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
    int L = sizeof(arr) / sizeof(arr[0]);
    sort(arr, L);
​
    system("pause");
    return 0;
}

第十三节课 结构体

1.1结构体基本概念

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

1.2结构体的定义与使用

 

#include <iostream>
using namespace std;
#include <string>//用了字符串类型
​
//1.创建数据类型：姓名，年龄，分数
struct student  //结构体创建变量时候，struct可以省略；定义时候不能省
{
    //成员列表
    string name;
    int age;
    int score;
}s3;//顺便创建结构体变量
​
//2.通过学生类型创建具体学生
​
​
int main()
{
//2.1 struct student s1
    struct student s1;  //结构体创建变量时候，struct可以省略；定义时候不能省
    //给s1属性赋值，通过.访问结构体变量中的属性
    s1.name = "张三";
    s1.age = 18;
    s1.score = 100;
​
    cout << "姓名:  " << s1.name  << " 年龄:  " << s1.age  << " 分数:  " << s1.score  << endl;
​
//2.2 struct student s2={..}
    struct student s2 = { "李四",18,90 };
    cout << "姓名:  " << s2.name << " 年龄:  " << s2.age << " 分数:  " << s2.score << endl;
​
//2.3 定义结构体时候，顺便创建结构体变量
    s3.name = "王五";
    s3.age = 18;
    s3.score = 80;
    cout << "姓名:  " << s3.name << " 年龄:  " << s3.age << " 分数:  " << s3.score << endl;
​
    system("pause");
    return 0;
}

1.3 结构体数组

作用：将自定义的结构体放入到数组中方便维护

语法：struct 结构体名 数组名[元素个数]={{}，{}，{}，...}

#include <iostream>
using namespace std;
#include<string>
​
//结构体数组
//1.定义结构体
struct student
{
    string name;
    int age;
    int score;
};
​
​
​
int main()
{
    //2.创建结构体数组
    struct student arr[3] =
    {
        {"张三",18,100},
        {"李四",19,90},
        {"王五",18,80}
    };
​
    //3.给结构体数组中的元素赋值
    //已经在2中定义了
    //也可以更改
    arr[2].name = "赵六";
    arr[2].age = 18;
    arr[2].score = 77;
        
    //4.遍历结构体数组
    for (int i = 0; i < 3; i++)
    {
        cout << "姓名：" << arr[i].name << "  年龄： " << arr[i].age << "  分数： " << arr[i].score << endl;
    }
​
    system("pause");
    return 0;
}

1.4 结构体指针

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

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

#include <iostream>
using namespace std;
#include<string>
​
//结构体指针
//1.定义结构体
struct student
{
    string name;
    int age;
    int score;
};
​
int main()
{
    //创建结构体变量
    struct student s = { "张三",19,100 };
​
    //通过指针指向结构体变量
    student * p = &s;
​
    //通过指针访问结构体变量中的数据   指针要用->来访问结构体属性
    cout << "姓名： " << p->name << "  年龄： " << p->age << "  分数： " << p->score << endl;
​
    system("pause");
    return 0;
}

1.5 结构体嵌套

作用：结构体中的成员可以是另一个结构体

例如：每个老师辅导一名学生，一个老师的结构体中，记录一个学生的结构体

#include <iostream>
using namespace std;
#include<string>
​
//结构体嵌套结构体
// 
//定义学生的结构体
struct student
{
    string name;
    int age;
    int score;
};
 
//定义教师结构体
struct teacher
{
    int id;
    string name;
    int age;
    struct student stu;//嵌套学生的结构体
};
​
int main()
{
    //结构体嵌套结构体
    struct teacher s1 =
    {
        10000,
        "老王",
        40,
        {"张三",18,80},
    };
​
    cout << "老师姓名:  " << s1.name << "  老师编导： " << s1.id << "  老师年龄： " << s1.age << "  老师辅导学生名字： " << s1.stu.name
        << "  学生年龄： " << s1.stu.age << "  学生分数： " << s1.stu.score << endl;
​
    system("pause");
    return 0;
}

1.6 结构体做函数参数

作用：将结构体作为参数向函数中传递

传递方式：值传递和地址传递

#include <iostream>
using namespace std;
#include<string>
​
//结构体函数
//定义学生的结构体
struct student
{
    string name;
    int age;
    int score;
};
 
void printstudent1(student s)//值传递
{
    s.age = 100;
    cout << "子函数中  姓名： " << s.name << "  年龄： " << s.age << "  分数： " << s.score << endl;
}
​
void printstudent2(student *s)
{
    s->age = 90;
    cout << "子函数2中 姓名： " << s->name << "  年龄： " << s->age << "  分数： " << s->score << endl;
​
}
​
int main()
{
    //结构体做函数的参数
    //将学生传入到一个参数中，打印学生所有信息
    student s = { "张三",18,100 };
    printstudent1(s);
    cout << "姓名： " << s.name << "  年龄： " << s.age << "  分数： " << s.score << endl;
    
    printstudent2(&s);
    cout << "姓名： " << s.name << "  年龄： " << s.age << "  分数： " << s.score << endl;
    system("pause");
    return 0;
}

1.7 结构体中 const使用场景

作用： 用const来防止误操作

#include <iostream>
using namespace std;
#include<string>
​
//结构体函数
//定义学生的结构体
struct student
{
    string name;
    int age;
    int score;
};
 
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
​
void printstudent1(const student *s)//加const防止误操作了
{
    //s->age = 88;//加入const之后，一旦有修改的操作就会报错，可以防止我们误操作
    cout << " 姓名： " << s->name << "  年龄： " << s->age << "  分数： " << s->score << endl;
}
​
int main()
{
    //创建结构体变量
​
    student s = { "张三",18,100 };
    printstudent1(&s);
    cout << "姓名： " << s.name << "  年龄： " << s.age << "  分数： " << s.score << endl;
    
    system("pause");
    return 0;
}

1.8结构体案例

1.8.1案例1

 

#include <iostream>
using namespace std;
#include<string>
#include<time.h>
​
struct student
{
    string name;
    int score;
};
​
struct teacher
{
    string name;
    student stu[5];
};
​
void printst(teacher tea[],int len)
{
    string nameseed = "abcde";
    for (int i = 0; i < len; i++)
    {
        tea[i].name = "teacher_";
        tea[i].name += nameseed[i];
        
        for (int j = 0; j < 5; j++)
        {
            tea[i].stu[j].name = "student_";
            tea[i].stu[j].name += nameseed[j];
​
            int random = rand() % 61 + 40;
            tea[i].stu[j].score = random;
        }
    }
}
​
void printall(teacher tea[], int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << "老师名字： " << tea[i].name << endl;
        for (int j = 0; j < 5; j++)
        {
             cout<< "\t学生名字： " << tea[i].stu[j].name << "  分数： " << tea[i].stu[j].score << endl;
        }
    }
​
}
​
int main()
{
    srand((unsigned int)time(NULL));//随机数
​
    teacher tea[3];
​
    int len = sizeof(tea) / sizeof(tea[0]);
    printst(tea, len);
    
    printall(tea, len);
​
    system("pause");
    return 0;
}

1.8.2 案例2

 

#include <iostream>
using namespace std;
#include<string>
​
struct gameman
{
    string name;
    int age;
    string sex;
};
​
void pai(gameman arr[], int len)
{
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 1; j < len - i; j++)
        {
            if (arr[j - 1].age > arr[j].age)
            {
                gameman temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}
​
void printall(gameman arr[], int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << "英雄名字： " << arr[i].name << "  年龄： " << arr[i].age << "  性别： " << arr[i].sex << endl;
    }
​
}
int main()
{
    gameman arr[5] =
    {
        {"刘备",23,"男"},
        {"关羽",22,"男"},
        {"张飞",20,"男"},
        {"赵云",21,"男"},
        {"貂蝉",19,"女"}
    };
​
    int len = sizeof(arr) / sizeof(arr[0]);
​
    pai(arr, len);
    printall(arr, len);
​
    system("pause");
    return 0;
}

华氏451度。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值