【C++基础语法】指针和引用（一）

1. 指针

 

 

 

 

 

#include <iostream>

int main()
{
    int a{ 5000 };

    int* pa{ &a };

    //*pa = 66666;

    (*pa)++;
    //int* b{};

    unsigned b{64543};

    unsigned* pb{&b};

    //*pb = 34325;

    float c{ 53.6f };

    float* pc{ &c };

    double d{ 784.2 };

    double* pd{ &d };

    std::cout << "内存地址:" << pa << "\na =" << *pa << std::endl;

    std::cout << "内存地址:" << pb << "\nb =" << *pb << std::endl;

    std::cout << "内存地址:" << pc << "\nc =" << *pc << std::endl;

    std::cout << "内存地址:" << pd << "\nd =" << *pd << std::endl;

    //std::cout << b << std::endl;

    return 0;
}

2. 指针数组

#include <iostream>

int main()
{
    int student[5]{ 1001,1002,1003,1004,1005 };

    int* ptrstudent[5];

    for (int x = 0; x < 5; x++)
    {
        ptrstudent[x] = &student[x];

        std::cout << "内存地址:" << ptrstudent[x] << "\n值" << *ptrstudent[x] << std::endl;
    }

    return 0;
}

3. 指针补充

 

 

​​​​#include <iostream>

int main()
{
    unsigned ua{ 9999 };
    int a{ 9999 };

    int* ptr{ &a };
    long long* uptr{ (long long*) & ua};
    

    ptr = (int*) & ua;

    //int* ptr{};

    char* cptr{};

    *ptr = -1;//ox FF FF FF FF

    cptr = (char*)ptr;//    

    *cptr = 'A';//65 ox41 FF FF FF //OX FF FF FF 41

    // FF FF FF FF ua
    // 00 00 00 00 未知 （&ua） + 4

    std::cout << sizeof(ptr) << std::endl;

    std::cout << sizeof(cptr) << std::endl;

    std::cout << ptr << std::endl;

    std::cout << *ptr << std::endl;

    std::cout << *uptr << std::endl;

    std::cout << ua << std::endl;




    return 0;
}

 

4. 指针实验一

 

 

#include <iostream>

int main()
{
    int a[]{ 10001,20001,30001,40001 };
    int* ptr{ &a[0] };

    std::cout << ptr << std::endl;

    //ptr = ptr + 1;

    //std::cout << (*ptr) ++ << std::endl;
    //std::cout << ++ (*ptr)  << std::endl;


    std::cout << a[0] << std::endl;


    std::cout << *ptr++ << std::endl;//先显示*ptr的值 然后让ptr++

    std::cout << (*ptr) ++ << std::endl;

    std::cout << a[0] << std::endl;

    std::cout << ptr << std::endl;

    std::cout << &a[1] << std::endl;

    std::cout << *ptr << std::endl;

    //指针加1的时候 加的是 +1 * 指针类型大小
    //std::cout << *ptr++ << std::endl;

    return 0;
}

5. 指针实验二

 

#include <iostream>

int main()
{
    int a[]{ 10001,10002,10003,10004 };

    int* ptr{ &a[0] };

    int** pptr{ &ptr };

    *pptr = &a[1]; 


    std::cout << *ptr << std::endl;

    std::cout << **pptr << std::endl;

    

    return 0;
}

6. 绕晕的指针概念

6.1 常量指针

#include <iostream>

int main()
{
    const int a{ 1000 };
    const int b{ 2500 };
    int c{ 3500 };
    const int* ptr{ &a };

    ptr = &c;

    //指向可以改 指向的内容不可改
    //*ptr = 2000;

    std::cout << *ptr;

    //错误 a是常量 只能读取 不能写入
    
    //*ptr = 500;

    //a是常量  ptr是变量 
    

    return 0;
}

6.2 指针常量

#include <iostream>

int main()
{
    int a{ 1000 };
    int b{ 1000 };

    int* const ptr{ &a };

    std::cout << *ptr << std::endl;

    //ptr 是一个常量 不能修改
    //ptr = &b;

    //指针指向的内存空间可以修改
    *ptr = 9999;

    std::cout << a;
    

    return 0;
}

 6.3 指向常量的常量指针

#include <iostream>

int main()
{
    const int a{ 1000 };
    const int b{ 2400 };

    const int* const ptr{ &a };

    //ptr 被第二个const限定 指针变量是一个常量
    ptr = &b;

    //这是一个常量指针 指向的内容不可被更改
    *ptr = 9999;
    

    return 0;
}

#include <iostream>

int main()
{
    const int a{ 1000 };
    const int b{ 2400 };

    const int* const ptr{ &a };

    //定义一个新的指针 强制转换为int*
    int* ptra{  (int*) & a};
    
    *ptra = 9500;

    std::cout << *ptra << std::endl;

    std::cout << a << std::endl;


    return 0;
}