c++学习3_31

指针

指针存放的是地址

可以通过解引用的方式来找到指针指向的内存
指针前面加 * 代表解引用，找到指针志向的内存中的数据

int a = 10;
    int *p;
    p = &a; 
    cout <<"a的地址为:"<<&a<<endl;
    cout <<"p的值为:"<<p<<endl;

    *p=1000;
    cout << "a的值为:"<<a<<endl;
    cout << "*p的值为:"<<*p<<endl;

指针所占用的空间

在32位操作系统下：占用4个字节空间
在64位操作系统下：占用8个字节空间

#include <iostream>
using namespace std;

int main ()
{
    //指针所占用的内存空间
    int a=10;
    int * p = &a;

    //cout << "sizeof (int *) = " << sizeof(p) <<endl;
    cout << "sizeof (int *) = " << sizeof(int *) <<endl;
    cout << "sizeof (float *) = " << sizeof(float *) <<endl;
    cout << "sizeof (double *) = " << sizeof(double *) <<endl;
    cout << "sizeof (char *) = " << sizeof(char *) <<endl;

    system("pause");
    return 0;
}

空指针和野指针

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

#include <iostream>
using namespace std;

int main()
{
    //空指针
    //1、空指针用来给指针变量进行初始化
    int *p = NULL;

    //2、空指针是不可以进行访问的
    //0~255之间的内存编号是系统占用的，程序无法访问
    *p = 100;

    system("pause");
    return 0;

}

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

#include <iostream>
using namespace std;

int main()
{
    //野指针
    //在程序中，尽量避免出现野指针
    int *p = (int *)0x1100;
    cout << "*p的值为:"<<*p<<endl;

    system("pause");
    return 0;
}

空指针和野指针都不是我们自己访问的空间，不要去访问。****

const修饰指针

有三种情况：
1、const修饰指针 ---常量指针
2、const修饰常量 ---指针常量
3、const既修饰指针，又修饰常量

1、常量指针
const int * p = &a;
特点：指针指向可以修改，但是指针指向的值不可以修改
*p = 20; 错的，改不了
p= &b； 对的，可以改

2、指针常量
int * const p = &a;

特点 指针指向的值可以改，但是指针指向不可以改
*p = 20; 对的，可以改
p = &b; 错误，指针指向不可以改

3、const 既修饰指针，又修饰常量
const int * const p = &a;
特点：指针的指向和指针指向的值都不能修改
*p = 20; 错的
p = &b; 错的

#include <iostream>
using namespace std;

int main()
{
    //1、const修饰指针  常量指针
    int a = 10;
    int b = 20;

    const int *p = &a;
    //指针指向的值不可以改，指向的值可以改
    //*p = 20; //错误，指针指向的值不可以改
    p = &b; //正确，指向的值可以改

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

    //3、const修饰指针和常量
    const int * const p3 = &a;
    //指针的值不可以改，指向的值也不可以改
    //p3 = &b; //错误，指针指向不可以改
    //*p3 = 20; //错误，指向的值不可以改


    system("pause");
    return 0;
}

指针和数组

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

#include <iostream>
using namespace std;

int main()
{
    //指针和数组
    //利用指针访问数组中的元素

    int arr[5] = {1,2,3,4,5};

    cout << "第一个元素是：" << arr[0] << endl;

    int * p =arr;//arr就是数组的首地址

    cout << "利用指针访问第一个元素：" << *p << endl;

    p++;//让指针向后偏移4个字节，指向第二个元素的地址

    cout << " 利用指针访问第二个元素：" << *p << endl;

    p++;//让指针向后偏移4个字节，指向第三个元素的地址

    cout << " 利用指针遍历数组" << endl;
    
    int * p2 = arr;
    for(int i=0;i<5;i++)
    {
        //cout << arr[i] << endl;
        cout << *p2 <<endl;
        p2++;//让指针向后偏移4个字节，指向下一个元素的地址
    }

    system("pause");
    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()
{
    //函数和指针
    //1、值传递
    int a = 10;
    int b = 20;

    swap(a,b);
    cout << "a的值为:"<<a<<endl;
    cout << "b的值为:"<<b<<endl;

    //2、地址传递
    swap02(&a,&b);
    cout << "地址传递后a的值为:"<<a<<endl;
    cout << "地址传递后b的值为:"<<b<<endl;


    system("pause");    
    return 0;
}

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

指针、数组、函数

封装一个函数，利用冒泡排序，实现对整形数组的升序排序

#include <iostream>
using namespace std;

//冒泡排序，参数1 数组的首地址，参数2 数组的长度
void bubbleSort(int * arr,int len)
{
    for (int i=0;i<len;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;
            }
        }
    }
}

int main()
{
    //1.先创建数组
    int arr[10] = {2,5,7,3,43,36,76,34,23,1};
    //数组长度
    int len = sizeof(arr)/sizeof(arr[0]);
    
    //2.调用函数，进行冒泡排序
    bubbleSort(arr,len);
    //3.打印排序后的数组
    for(int i=0;i<len;i++)   
    {
        cout << arr[i] << endl;
    }
    system("pause");
    return 0;
}

结构体

结构体属于用户自动以的数据类型，允许用户存储不用的数据类型

结构体的定义和使用

语法：struct 结构体名 {结构体成员列表}；
通过结构体创建变量有三种方式：
1。struct 结构体名 变量名
2。struct 结构体名 变量名 = {成员1值，成员2值}
3。定义结构时顺便创建变量

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

//1、创建学生数据类型：学生包括（姓名，年龄，成绩）
//自定义数据类型，一些数据集合组成的一个类型
struct Student//此时struct不能够省略。定义的时候
{
    //成员列表

    //姓名
    string name;
    //年龄
    int age;
    //成绩
    double score;
}s3; //定义结构体时顺便创建变量

//2、通过学生类型创建具体学生
int main()
{
    //2.1 struct Student s1;
    //struct可以是省略
    Student s1;
    //struct Student s1;
    s1.name = "张三";
    s1.age = 20;
    s1.score = 99.5;

    cout << "姓名:" << s1.name<<"年龄:"<<s1.age<<"成绩:"<<s1.score<<endl;
    
    //2.2 struct Student s2 = {"张三",20,99.5};
    struct Student s2 = {"李四",21,88.0};
    cout << "姓名:" << s2.name<<"年龄:"<<s2.age<<"成绩:"<<s2.score<<endl;
    
    //定义结构体时顺便创建变量
    //2.3 struct Student s3 = {100,"李四",21,88.0};
    s3.name = "王五";
    s3.age = 21;
    s3.score = 88.0;
    cout << "姓名:" << s3.name<<"年龄:"<<s3.age<<"成绩:"<<s3.score<<endl;

    system("pause");
    return 0;
}

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

结构体数组

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

#include <iostream>
using namespace std;

//结构体数组
//1、定义结构体
struct Student
{
    //成员列表

    //姓名
    string name;
    //年龄
    int age;
    //成绩
    double score;
};

int main()
{
    //2、创建结构体数组
    
    Student stuArray[3] = 
    {
        {"张三",20,99.5},
        {"李四",21,88.0},
        {"王五",22,77.0}
    };
    //3、给结构体数组中的元素赋值  
    stuArray[2].name = "赵六";
    stuArray[2].age = 23;
    stuArray[2].score = 88.0;
    
    //4、遍历结构体数组
    for(int i = 0;i < 3;i++)
    {
        cout << "姓名:" << stuArray[i].name
             <<"年龄:"  <<stuArray[i].age
             <<"成绩:"  <<stuArray[i].score
             <<endl;
    }


    system("pause");
    return 0;
}

结构体指针

*作用通过指针访问结构体中的成员
利用"->"可以通过结构体指针来访问结构体属性