范磊 C++ 第8章 指针

// section_8.cpp : Defines the entry point for the console application.
//范磊 C++ 第8章 指针
//指针本质也是一个变量,只是这个变量存放的数据比较特殊,怎么特殊?
//里面存放的是别人家的地址. 其他变量的内存编号而已.

#include "stdafx.h"
#include "iostream"

using namespace std;

//--------------------------------------------------
//8.1 地址
//地址,可以理解为:每一个内存都有自己的空间编号,这个编号称为"地址"
void fun1()
{
    int i;

    i = 1;
    cout << &i << endl ;    // &是取地址符号,在变量名字前面 +&,表示获得这个变量 i 的内存编号.
}                            //c++直接回输出一个16进制的数字.不向c那样,前面要 %x 表示16进制.


//--------------------------------------------------
//8.2 用指针来保存地址
//用一个特别的变量(指针)去存放其他变量的内存地址.
void fun2()
{
    int a;
    int* p;

    p = &a;
    cout << &a << endl;        //打印出变量a的地址 0018ffe0
    cout << p << endl;        //打印出变量a的地址 0018ffe0,所以说指针p 保存了变量a的地址.
}


//-------------------------------------------------
//8.21 空指针(好像不是很适合叫空指针)
//当我们定义了一个指针后,如果不初始化,这个"迷途指针"里面的内容是一个随机数
//所以我们要给指针赋值,赋个0给他.
void fun3()
{
    int* p;
    p = 0;
    cout << "p: " << p << endl;
}


//-------------------------------------------------
//8.2.3 用指针来访问值
// 符号 * 称为指针运算符. 意思是取出指针里面的地址的内容.
//例如 指针p = 1234567 ,*p 的意思就是 取出内存地址单元编号为1234567 里面的内容.
//汇编理解:  mov Exr, ds:[1234567]
void fun4()
{
    int a;
    int* p;

    a = 1;
    p = &a;

    cout << "&a的值为:" << "\t" << &a << endl ;
    cout << "a的值为:" << "\t"  << a << endl ;
    cout << "p的值为:" << "\t"  << p << endl ;
    cout << "*p的值为:" << "\t"  << *p << endl;
}
//打印的结构是 a == 1 , *p == 1.  


//-------------------------------------------------
//8.2.4 指针地址,指针保存的地址和该地址的值
//指针的地址: 因为指针的本质其实也是一个变量,这个变量肯定占用内存空间,肯定有内存单元编号
//指针保存的地址:指针里面存放的数据,这个数据不是一般普通数据,这个数据是其他内存的单元编号(地址).
//该地址的值:可以通过指针里面的地址,按照地址去找到那个内存,看看里面放的是什么数据.
void fun5()
{
    int i;
    int* p;

    cout << "i的地址为: " << &i << endl ;
    cout << "p的值为: " << p << endl ;        //此时p还没赋值,属于一个"迷途指针"
    cout << "p的地址为: " << &p << endl ;    //p虽然是迷途指针,但前面已经进行int* p 声明了.
                                            //所以p也有自己的地址.
    i = 3;
    cout << "i赋值后的地址为: " << &i << endl ;

    p = &i;                                        //把 i 的地址告诉了p.
    cout << "p赋值后的值为: " << p << endl ;    //p里面存放就是i的地址.
    cout << "p赋值后的地址为: " << &p << endl ;

}


//-------------------------------------------------
//8.2.5 指针对数值的操作
//可以通过 * 号,间接访问或读取指针的保存的地址里面的数据
typedef unsigned short int ut;    //因为unsigned short int 这个类型名字很长,另外起了个小名 ut
void fun6()
{
    //cout << sizeof(ut) << endl ;    //测试一下ut是占用了多大内存空间
    ut i;
    ut* p = 0;
    
    i = 5;
    p = &i;        //自从当执行p = &i以后, 改变了*p就是改变了i,改变了i就是改变了*p

    cout << "i = " << i << endl ;
    cout << "*p = " << *p << endl;

    cout << "用指针来修改存放在i中的数据...\n"  ;
    *p = 90;
    cout << "i = " << i << endl ;
    cout << "*p = " << *p << endl;

    cout << "用i来修改存放在i中的数据...\n"  ;
    i = 9;
    cout << "i = " << i << endl ;
    cout << "*p = " << *p << endl;
}


//-------------------------------------------------
//8.2.6 更换指针保存的地址
//平时,小明口袋里放着怎么去小芳家的地图,所以他只知道小芳家有什么东西.
//今天他口袋了放的是去小李家的地图,所以他只知道小李家有什么东西.不知道小芳家有什么东西.
void fun7()
{
    int i;
    int j;
    int* p;
    
    i = 10;
    j = 20;
    p = &i;        //p存放着的是i的地址,所以p知道i里面有什么东西.

    cout << "i:" << "\t" << i <<endl ;
    cout << "&i:" << "\t" << &i << endl ;
    cout << "j:" << "\t" << j <<endl ;
    cout << "&j:" << "\t" << &j << endl ;
    cout << "p:" << "\t" << p <<endl ;
    cout << "*p:" << "\t" << *p << endl ;    //*p获得就是i的内存里面的内容.

    p = &j;        //p存放着的是j的地址,所以p知道j里面有什么东西.

    cout << "更换地址后...\n" ;
    cout << "i:" << "\t" << i <<endl ;
    cout << "&i:" << "\t" << &i << endl ;
    cout << "j:" << "\t" << j <<endl ;
    cout << "&j:" << "\t" << &j << endl ;
    cout << "p:" << "\t" << p <<endl ;
    cout << "*p:" << "\t" << *p << endl ;    //*p获得就是j的内存里面的内容.
}


//-------------------------------------------------
//8.3.2 用指针创建堆中空间
//什么叫堆?(3个特点):1.堆是一大堆不连续的内存区域;2.堆生存的时间要比栈长;3.堆要手动申请,手动释放;
//C++中,用关键字 new 创建一个堆,并分配内存.
void fun8()
{
    int* p;
    p = new int; //这里如果直接写 new int 是不会报错的,但不能运行.为什么?
                 //堆是一大堆大小不连续的内存区域,在系统中由链表串接起来使用,堆中的每个内存单元都是
                 //匿名的,因此必须先在对堆中申请一个内存单元地址,然后保存在一个指针中,只有使用该指针
                 //才能访问到该内存单元的数据.
    *p = 4;
    cout << *p << endl ;            //堆的内容
    cout << "p: " << p << endl;        //堆的地址
    cout << "&p: " << &p << endl;   
}
//函数的框架是esp-48h,多了的8个字节是怎么来?
//int* p 这里多了4个字节. 另外是 new int 这里也多了4个字节.


//-------------------------------------------------
//8.3.3 用指针删除堆中空间(成也萧何败也萧何)
//C++中,用关键字 delete 释放堆的空间.否则的话,会造成内存泄露.
//什么叫内存泄露?
//堆的地址一定是在指针里面的,只有指针才知道怎么去找到堆.如果指针丢了,那么其他任何途径都找不到这个堆了.
//一个宝藏地图只有小明知道,但是小明死了,其他人永远也别想找到宝藏的位置了.
void fun9()
{
    int* p;
    p = new int;
    *p = 3600;

    cout << *p << endl ;

    delete p;
    cout << *p << endl ;    //p已经变成了迷途指针了.

    p = 0;
    p = new int;
    *p = 8;
    cout << *p << endl ;
    
    delete p;
    cout << *p << endl ;
}


//-------------------------------------------------
//8.4.2 在堆中删除对象
class A
{
private:
    int i;
public:
    A()
    {
        cout << "构造函数执行中...\n" ;
        i = 0x999;
    }
    ~A()
    {
        cout << "析构造函数执行中...\n" ;
    }
    int get()
    {
        return i;
    }
};
void fun10()
{
    A* p;
    p = new A;
    delete p;
}
//函数框架不明白.



//-------------------------------------------------
//8.4.4 访问对中的数据成员
//必须要通过指针才能访问堆.
class A1
{
private:
    int i;
public:
    int get() const
    {
        return i;
    }
    void set(int x)
    {
        i = x;
    }
};
void fun11()
{
    A1* a;
    a = new A1;
    a->set(66);        //通过 -> 符号来访问堆.
    cout << a->get() << endl ;
    delete a;
}


//-------------------------------------------------
//8.4.5 在构造函数中开辟内存空间
class A2
{
private:
    int* i;
public:
    A2();
    ~A2();
    int get() const
    {
        return *i;
    }
    void set(int x)
    {
        *i = x;
    }
};
void fun12()
{
    A2* p;
    p = new A2;
    cout << p->get() << endl ;
    p->set(0) ;
    cout << p->get() << endl ;
    delete p ;
}
A2::A2()
{
    cout << "构造函数执行中... \n" ;
    i = new int(999) ;
}
A2::~A2()
{
    cout << "析构函数执行中... \n" ;
    delete i ;
}


//-------------------------------------------------
//8.4.6 对象在栈与堆中的不同
class A3
{
private:
    int* i;
public:
    A3();
    ~A3();
    int get() const    //const加在这里什么意思?
    {
        return *i;
    }
    void set(int x)
    {
        *i = x;
    }
};
void fun13()
{
    A3* p;
    p = new A3;        //开辟新的内存空间,空间的首地址放到了p里面.?
    cout << p->get() << endl ;
    p->set(123);
    cout << p->get() << endl ; 
}
A3::A3()
{
    cout << "构造函数执行中... \n" ;
    i = new int(999) ;
}
A3::~A3()
{
    cout << "析构函数执行中... \n" ;
    delete i ;
}


//-------------------------------------------------
//8.5 this指针
//this指针记录每个对象的内存地址,然后通过间接引用符 -> 访问该对象的成员.
class A4
{
private:
    int i;
public:
    int get() const
    {
        return i;
    }
    void set(int x)
    {
        this-> i;
        i = x;
        cout << "this变量保存的内存地址: \t" << this << endl ;
    }
};

void fun14()
{
    A4 a;
    a.set(99);
    cout << "对象a的内存地址: \t\t" << &a << endl;
    cout << a.get() << endl;

    A4 b;
    b.set(9999);
    cout << "对象b的内存地址: \t\t" << &b << endl;
    cout << b.get() << endl;

}



//-------------------------------------------------
//8.6 指针的常见错误
//删除一个指针后,一定要将该指针设定为赋值为0.因为删除该指针只会释放它指向的内存空间,不会删除指针.
//因此这个指针还存在,并且仍会指向原来的内存空间,这时如果再次尝试使用该指针,将导致程序出错.
void fun15()
{
    int* p;
    p = new int;
    *p =3;

    cout << "将3赋值给p的地址后,指针p读取的值: \t" << *p << endl ;
    delete p;
    cout << "删除空间后,指针p读取的值: \t\t" << *p << endl ;

    long* p1;
    p1 = new long;
    cout << "创建新空间后,指针p中的保存地址: \t " << p << endl;
    *p1 = 99999;
    cout << "指向新空间的指针p1保存的地址: \t\t" << p1 << endl;
    *p = 23;
    cout << "将23赋值给p的地址后,指针p读取的值: \t" << *p << endl;
    cout << "将23赋值给p的地址后,指针p1读取的值: \t" << *p1 << endl;
    delete p1;
}


//-------------------------------------------------
//8.7.1 指针的加减运算
void fun16()
{
    int* p;
    p = new int;
    cout << "指针p保存的空间地址为: \t" << p << endl ;
    p++;
    cout << "自加后,指针p保存的空间地址为: " << p << endl ;
    p--;
    cout << "自减后,指针p保存的空间地址为: " << p << endl ;
    p -= 2;
    cout << "减2后,指针p保存的空间地址为: " << p << endl ;    
}



//-------------------------------------------------
//8.7.2 指针的赋值运算
void fun17()
{
    int* p;
    p = new int;
    cout << "p:" << p << endl;
    int* p1;
    p1 = new int;
    cout << "p1:" << p1 << endl;
    p = p1;
    cout << "赋值后...\n" ;
    cout << "p:" << p << endl;
}


//-------------------------------------------------
//8.7.3 指针的相减运算
void fun18()
{
    int* p;
    p = new int;
    cout << "p:" << p << endl;
    int* p1;
    p1 = new int;
    cout << "p1:" << p1 << endl ;
    *p = p - p1;    //两个地址相减,得出的是一个数字.
    cout << "两个内存的地址差: " ;
    cout << *p << endl;
}



//-------------------------------------------------
//8.7.4 指针的比较运算
void fun19()
{
    int* p;
    p = new int;
    cout << "p:" << p << endl ;
    int *p1;
    p1 = new int;
    cout << "p1:" << p1 << endl ;
    if(p > p1)
    {
        cout << "p大于p1的内存地址. \n" ;
    }
    else
    {
        cout << "p1大于p的内存地址. \n" ;
    }

}


//-------------------------------------------------
//8.8.1 常量指针
//常量指针:指针的值不能改变. 这个指针是一个常量,是一个不变量.
class A5
{
private:
    int i;
public:
    int get() const
    {
        return i;
    }
    void set(int x)
    {
        i = x;
    }
};
void fun20()
{
    A5* p;
    p = new A5;
    cout << "p:" << p << endl ;
    p += 1;
    cout << "p:" << p << endl ;

    A5* const p1 = new A5;    //error C2734: 'p1' : const object must be initialized if not extern
    //p1 = new A5;   不能再这样写了.报上面的错.
    //p1 += 1;        //因为前面const p1说明了p1是不能改变的.如果非要执行这句的话,编译出错.
    p1->set(6);
    cout << p1->get() << endl;

}



//-------------------------------------------------
//8.8.2 指向常量的指针
class A6
{
private:
    int i;
public:
    int get() const
    {
        return i;
    }
    void set(int x)
    {
        i = x;
    }
};
void fun21()
{
    const A6* p;    // const(A6* p) ,说明这个(A6* p)的值是一个常量.
    p = new A6;
    p += 1;            
    //p->set(11);
    cout << p->get() << endl ;
}


//-------------------------------------------------
//8.8.3 指向常量的常指针
class A7
{
private:
    int i;
public:
    int get() const
    {
        return i;
    }
    void set(int x)
    {
        i = x;
    }
};
void fun22()
{
    const A7*  const p = new A7;      //'p' : const object must be initialized if not extern
    //p = new A7;          //不能这样写了.
    //p += 1;              //因为指针是常量,所以这里要进行指针改变,不能通过编译.
    //p->set(11);          //因为指针指向的内容页是常量,所以这里要进行修改,也不能通过编译.
    cout << p->get() << endl ;
}


//////////////////////第8章主要例子完毕///////////////////////


int main(int argc, char* argv[])
{
    //fun1();        //8.1 地址
    //fun2();        //8.2 用指针来保存地址
    //fun3();        //8.2.1 空指针
    //fun4();        //8.2.3 用指针来访问值
    //fun5();        //8.2.4 指针地址,指针保存的地址和该地址的值
    //fun6();        //8.2.5 指针对数值的操作
    //fun7();        //8.2.6 更换指针保存的地址
    //fun8();        //8.3.2 用指针创建堆中空间
    //fun9();        //8.3.3 用指针删除堆中空间
    //fun10();        //8.4.2 在堆中删除对象
    //fun11();        //8.4.4 访问对中的数据成员
    //fun12();        //8.4.5 在构造函数中开辟内存空间(不明白)
    //fun13();        //8.4.6 对象在栈与堆中的不同(不明白)
    //fun14();        //8.5 this指针                
    //fun15();        //8.6 指针的常见错误
    //fun16();        //8.7.1 指针的加减运算
    //fun17();        //8.7.2 指针的赋值运算
    //fun18();        //8.7.3 指针的相减运算
    //fun19();        //8.7.4 指针的比较运算
    //fun20();        //8.8.1 常量指针
    //fun21();        //8.8.2 指向常量的指针
    //fun22();        //8.8.3 指向常量的常指针

    return 0;
}