C++ （9）代码及指针知识点巩固

代码

水仙花数

#include <iostream>
using namespace std;

int main()
{
    //水仙花数
    int num = 100;
    do
    {
        int a = 0;
        int b = 0;
        int c = 0;

        a = num / 100;
        b = num / 10 % 10;
        c = num % 10;

        if(num == a*a*a + b*b*b + c*c*c)
        {
            cout << "100到999之间的水仙花数为：" << num << endl;
        }

        num++;
    } while (num < 1000);

    system("pause");
    return 0;
}

敲桌子

#include <iostream>
using namespace std;

int main()
{   
    // 敲桌子个位有7 十位有7 7的倍数
    for (int i = 1; i < 101; i++)
    {
        int num = i;
        int a = 0;
        int b = 0;
        a = num / 10;
        b = num % 10;

        if(a == 7 || b == 7 || num % 7 == 0)
        {
            cout << "敲桌子" << endl;
        }
        else
        {
            cout << num << endl;
        }
    }

    system("pause");
    return 0;
}

函数分文件编写

• 创建.h头文件，头文件写函数的声明
• 创建.cpp的源文件，源文件写函数的定义

指针

指针的作用

通过指针间接访问内存

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

int a = 10;  地址编号、变量名、值

指针保存变量地址

#include <iostream>
using namespace std;

int main()
{
    // 定义变量a，值为10
    int a = 10;
    // 定义指针
    int * p;
    // 指针记录变量a的地址，取a的地址
    p = &a;
    cout << "a的地址为：" << &a << endl;
    cout << p << endl;

    // 访问指针所指向的内存，并修改
    // *p为解引用
    *p = 1000;
    cout << "a为：" << a << endl;
    cout << "*p为：" << *p << endl;

    // system("pause");

    // x86 指针为4字节  x64 指针为8字节
    //指针编号从0开始，指向内存中编号为0的空间为空指针，不可以访问
    // 空指针给指针变量进行初始化
    int *p = NULL;
    // 空指针不可访问,0~255之间的内存编号是系统占用的

    // 野指针  指针变量指向非法空间
    int *p = (int *)0x1100;
    // 0x1100这块空间没有声明任何变量，没有分配一块内存，没有权限访问

    // const修饰指针——常量指针
    // 指针的指向可以修改，但指针指向的值不可以修改
    const int *p = &a;

    // 指针常量  指针的指向不可以改，指针指向的值可以修改
    int *const p = &a;

    // const既修饰指针，又修饰常量  指针的指向和指针指向的值都不可以改
    const int *const p = &a;

    // 指针和数组，利用指针访问数组中的值
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    cout << "第一个元素为：" << arr[0] << endl;
    int *p = arr; // arr就是数组首地址
    cout << "利用指针访问第一个元素：" << *p << endl;

    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    // 指针和数组，利用指针访问数组中的值
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    cout << "第一个元素为：" << arr[0] << endl;
    int *p = arr; // arr就是数组首地址
    cout << "利用指针访问第一个元素：" << *p << endl;
    cout << "数组长度为：" << sizeof(arr) << endl;
    for (int i = 0; i < (sizeof(arr) / sizeof(arr[0])); i++)
    {
        cout << "元素为：" << *p << endl;
        p++;  // 向后移4位
    }

    return 0;
}

值传递和地址传递

#include <iostream>
using namespace std;

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

void swap02(int *p1, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

int main()
{
    // 值传递，不改变实参值
    int a = 10;
    int b = 20;
    swap(a, b);
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
    
    // 地址传递，会改变实参值
    swap02(&a, &b);
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
    
    return 0;
}

指针、函数、数组

#include <iostream>
using namespace std;

template<class T>

// 获取数组长度
int arrLength(T& arr)
{
    int len = sizeof(arr) / sizeof(arr[0]);
    return len;
}

// 冒泡排序
void bubbleSort(int * arr, int len)
{
    for (int i = 0; i < len - 1; i++) // 总共大循环比较次数为len-1次
    {
        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 printArr(int * arr, int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << *arr << endl;
        arr++;
    }
}

int main()
{
    int arr[10] = {4, 3, 6, 9, 1, 2, 10, 8, 7, 5};
    int arr_len = arrLength(arr);
    cout << "数组长度为：" << arr_len << endl;

    bubbleSort(arr, arr_len);

    printArr(arr, arr_len);

    return 0;
}

结构体

用户自定义的数据类型

#include <iostream>
using namespace std;
#include <string>

struct Student
{
    string name;
    int age;
    float score;
};

struct Teacher
{
    int id;
    string name;
    int age;
    struct Student stu;  // 结构体嵌套
};

void printArr(Student * stuArr)
{
    for (int i = 0; i < 3; i++)
    {
        cout << stuArr[i].name << endl;
    }
}

// 打印学生信息函数，结构体值传递  值传递形参改变，实参不改变
void printStudent(Student s)
{
    cout << "学生姓名：" << s.name << " 学生年龄：" << s.age << " 学生分数：" << s.score << endl;
}

// 结构体地址传递  值传递形参改变，实参也改变
void printPStudent(struct Student * p)
{
    cout << "学生姓名：" << p->name << " 学生年龄：" << p->age << " 学生分数：" << p->score << endl;
}

int main()
{
    struct Student s1;  // struct 可以省略
    s1.name = "aaa";
    s1.age = 30;
    s1.score = 99.5;

    Student s2 = {"b", 10, 100.0};

    cout << "姓名：" << s1.name << " 年龄：" << s1.age << " 分数：" << s1.score << endl;
    cout << "姓名：" << s2.name << " 年龄：" << s2.age << " 分数：" << s2.score << endl;

    struct Student stuArray[3] = {
        {"ccc", 50, 66.5},
        {"ddd", 32, 45.5},
        {"eee", 78, 79.5},
    };
    printArr(stuArray);

    // 通过指针访问结构体变量中的数据，需要->访问结构体属性
    Student *p = &s1;
    cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;

    Teacher t1 = {123, "teacher1", 33, s2};
    t1.stu.name = "测试";
    cout << "姓名：" << t1.name << " 年龄：" << t1.age << " 学生姓名：" << t1.stu.name << " 学生分数：" << t1.stu.score << endl;

    cout << "值传递------------------------" << endl;
    printStudent(stuArray[0]);
    cout << "地址传递------------------------" << endl;
    printPStudent(&s1);

    return 0;
}