13245

对象各自的this指针指向各自对象的首地址，所以不同对象的this指针一定指向不同的内存地址

const 主要的作用？

固定常数据成员？

定义对象引用时，直接赋值

定义对象指针时，要取地址

加了const实际上是改变了权限，只读权限

const 修饰基本类型，同#define

const修饰对象，通过初始化列表初始化

const修饰成员函数，隐含参数this，故不能修改数据成员

同名的有无const修饰的两个函数，互为重载，但是一般没必要

使用常对象调用的是常成员函数

浅拷贝存在的问题：

    当对象的数据成员中包含指针变量时，浅拷贝有可能出现两个指针指向同一块内存区域的现象，这会导致对两个对象的写操作被覆盖，甚至可能会出现同一块内存被释放两次的情况，造成系统崩溃。

Coordinate * const pCoor = &coor1 : 这种方式定义的常指针“只能指向coor1，但可以调用coor1的不同的函数”；（拥有读写权限） const Coordinate *pCoor = &coor1  : 只能调用coor1的“常成员函数”。（只拥有读权限）

常对象引用与常对象指针 

const Coordinate& coor2 ; const Coordinate *p; 只具有读权限，所以只能调用常成员函数。调用成员函数过程其实就是一个隐式的this指针，普通成员函数传递的是Coordinate *this指针，而常成员函数传递的是常指针const Coordinate *this(只具有读权限)。 注意，Coordinate * const p，该指针表明指针地址为常量，指针所指向的对象值是可以改变的，也就是说该指针具有读写权限

用const修饰对象成员，对象成员就变成了常对象成员 用const修饰成员函数，成员函数就变成了常成员函数。const要放在函数的最后， 一旦初始化就不能再修改，const就是干这个的，长对象成员用初始化列表初始化 函数里看着没有参数，实际上隐藏着this指针。常成员函数中隐藏的是常this指针,常指针指向的数据不允许被修改 例如：void Coordinate::changeX(){m_iX = 10;}即为void Coordinate::changeX(Coordinate *this){this->m_iX = 10;} void Coordinate::changeX()const{m_iX = 10;}即为void Coordinate::changeX(const Coordinate *this){this->m_iX = 10;}这里的m_iX = 10;的写法是错误的，this已经是常指针,通过常指针是无法修改值的 void changeX();与void changeX() const互为重载 要调用const修饰的常成员函数，实例化对象时，必须用const来修饰对象，const写在最前面

1、 Array ... return *this 相当于： Array arrX = arr1; arrX是一个新的对象。即返回的this指针为另一个临时对象 2、 Array& ... return *this 相当于： Array & arrX = arr1; 此时arrX是arr1的别名。 3、 Array* ... return this 相当于： Array* arrX = this; 此时arrX的值 是地址，且是指向arr1的。用->访问或者*p. 访问

1.对象成员指针可以在初始化列表中初始化也可以在构造函数中初始化。

1. 对象指针：类名 * 指针名  = new 类名

2. 
   

1.对象成员：

对于复合类来说，子类的构造函数中如果存在参数，那么母类必须通过初始化列表的形式来对母类对象中的子类对象进行赋值。如图中的坐标系类

/****************Array.h*******************/
class Array{
    public:
        Array(int len);
        ~Array();
        Array* setLen(int len);
        int getLen();
        Array* printInfo();
    private:
        int len;
};
/****************Array.cpp*******************/
#include"Array.h"
#include<iostream>
using namespace std;
Array::Array(int len){
    this->len = len;
}
Array::~Array(){}
Array* Array::setLen(int len){
    this->len = len;
    return this;
}
int Array::getLen(){
    cout<<"len="<<len<<endl;
    return this->len;
}
Array* Array::printInfo(){
    cout<<"len="<<len<<endl;
    return this;   //this是指针，*this就是一个对象
}
/****************demo.cpp*******************/
#include<stdlib.h>
#include<iostream>
#include"Array.h"
using namespace std;
int main(void){
    Array arr1(2);
    Array  *arr2;
    arr2 = &arr1;
    arr2->printInfo()->setLen(3)->printInfo();
    arr2->getLen();
    system("pause");
    return 0;
}

/***************arry.h******************/
class arry
{
    public:
        arry(int _count);
        virtual ~arry();
        arry (const arry &arr);
        void setCount(int _count);
        int getCount();
        void printAddr();
        void printarr();
    protected:
    private:
        int m_iCount;
        int *m_pArr;
};
/***************arry.cpp******************/
#include<iostream>
#include"arry.h"
using namespace std;
arry::arry(int _count)
{
    m_iCount = _count;
    m_pArr = new int[m_iCount];
    for(int i = 0;i<m_iCount;i++){
        m_pArr[i] = i;
    //cout<<i<<endl;
    }
    cout<<"arry(int _count)"<<endl;
}
arry::arry(const arry& arr){
    m_pArr = new int[m_iCount];
    m_iCount = arr.m_iCount;
    //m_pArr = arr.m_pArr;
    for(int i = 0;i<m_iCount;i++){
        m_pArr[i] = arr.m_pArr[i];
    }
    cout<<"arry(const arry& arr)"<<endl;
}
void arry:: setCount(int _count){
    m_iCount = _count;
}
int arry:: getCount(){
    return m_iCount;
}
void arry:: printAddr(){
    cout<<"m_pArr的值："<<m_pArr<<endl;
}
void arry::printarr(){
    for(int i = 0;i<m_iCount;i++){
    cout<<m_pArr[i]<<endl;
    }
}
arry::~arry()
{
    delete []m_pArr;
    m_pArr = NULL;
    cout<<"~arry()"<<endl;
    //dtor
}
/***************demo.cpp******************/
#include<iostream>
#include<stdlib.h>
#include"arry.h"
using namespace std;
int main(void){
    arry arr1(6);
    //arr1.setCount(6);
    arry arr2 = arr1;
    arr1.printAddr();
    arr2.printAddr();
    arr2.printarr();
    system("pause");
    return 0;
}