对象指针与对象引用

对象指针

即指向对象的指针,定义的时候与正常指针一样。

int *p;//int型的指针
Date *d;//Date型的指针
//Date是一个类

对象指针包含类的所有成员,但调用成员的时候需要用符号->,而非正常对象用到的.。比如在如下类体中:

class Date{
private:
    int y,m,d;
public:
    void print(){
        cout<<y<<m<<d;
    }
    int t;
};

若有指向对象的指针Date *p;,则相应的变量调用方式为:

p->t;//调用的时候不带*
p->print();

对象指针的赋值

有两种赋值方式,均可以选择在定义的时候直接赋值,或先定义,再赋值:

  • 使用同类对象的地址给对象指针赋值。
Date d;
Date *p1=&d;//定义的时候直接赋值
Date *p2;//先定义后赋值
p2=&d;//赋值的时候不带*
  • 使用运算符new赋值。系统会创建一个对象,把这个新创建的对象的地址赋给指针。创建对象时,要用到构造函数,所以new之后的部分要匹配构造函数的格式
class Date{
private:
    int y,m;
public:
    Date(){
    y=2020,m=5;
    }
    Date(int Y, int M){
        y=Y,m=M;
    }
    void print(){
        cout<<y<<" "<<m<<endl;
    }
};
int main()
{
    Date *p1=new Date;//无参构造函数,注意这里不必写()
    Date *p2;
    p2=new Date(2019,9);//有参构造函数
    p1->print();
    p2->print();
    return 0;
}

输出:

2020 5
2019 9

用对象指针作函数参数

用对象指针作为函数的参数,可以实现传址调用,通过指针改变它所指向的对象的值。运行效率较高。而如果只是用普通对象作为参数,那么函数无法改变原对象的值,只能借来用一下,如下案例:

class Date{
public:
    int y,m;
    Date(){y=2020,m=5;}
};
void change1(Date a){ //普通对象作为参数
    a.y=1314;
    a.m=9;
}
void change2(Date *p){ //对象指针作为参数
    p->y=1314;
    p->m=9;
}
int main()
{
    Date a,*p=&a;
    change1(a);//a没有被改变
    cout<<a.m<<" "<<a.y<<endl;
    change2(p);//通过p改变了a
    cout<<a.m<<" "<<a.y;
    return 0;
}

输出:

2020 5
1314 9

常对象指针or指向对象的常指针

  • 类名 *const 指针名表示指向对象的常指针,特点是赋值后只能指向目前的变量,不可以让它指向别的变量就像你粉的cp锁死了,不能再跟别人组成cp
Date a,b;
Date *const p=&a;//锁死!
//p=&b;不行!

ps.这里的“锁死”指的是匹配关系的锁死,但可以通过指针改变该对象的值,大概就像:

往后余生 风雪是你 平淡是你 清贫也是你 荣华是你 心底温柔是你 目光所至 也是你

无论你变成什么样,只要是你就可以

  • const 类名 *指针名表示常对象指针(又称常指针),特点是不能通过该指针改变相应对象的值,只能读取,就像“只读”模式一样。
Date a, b;
const Date *p=&a;

ps. 常指针不可以改变它所指向对象的值,但可以“换对象”,指向其他对象。就像渣男一样

const Date *p=&a;
p=&b;//换对象
p=&c;//换对象

pps. 常对象只能用常对象指针指向(好绕)

const Date d;//常对象
const Date *p1=&d;//可以
Date *p2=&d;//不行!

ppps. 常对象指针应该调用常成员函数,不能调用普通函数

class Date{
public:
    int y,m;
    void print()const { //常成员函数
        cout<<666;
    }
};
int main()
{
    Date a;
    Date *const p=&a;
    p->print();//调用常成员函数
    return 0;
}

this指针

this指针由每个对象自动创建,指向自己,在实际编程中往往被省略,但需要的话也可以写出来。

class Date{
private:
    int y;
public:
    void plus(){
        this->y++;
        //相当于y++;
        cout<<this->y;
        //相当于cout<<y;
    }
    Date(){y=0;}
};
int main()
{
    Date a;
    a.plus();
    return 0;
}

输出:

1

只有类的一般成员函数可以使用this指针,类的友元函数、静态成员函数、类体外的一般函数等,都不能用this指针。

对象引用

与对象指针类似,但在实际应用中,使用对象引用作为函数的参数,要比使用对象指针更加普遍。

class Date{
private:
    int y;
public:
    void change(Date &d){ //对象引用作为函数的形参
        y=d.y;
        cout<<y;
    }
    Date(){y=0;}
    Date(int Y){
        y=Y;
    }//两个打酱油的构造函数
};
int main()
{
    Date a, b(5);
    a.change(b);//注意这里的()内只填b,没有&
    return 0;
}

输出:

5

实际应用中,也可以把上面的change函数按照如下方式修改:

void change(const Date &d){ //常对象引用
        y=d.y;
        cout<<y;
    }

此时函数的参数叫做常对象引用,类比常对象指针可知,常对象引用没有权限改变引用对象本身的值,只能借来用一下


本人是在读大学生,系列教程主要为了便于我的同学们参考,其中可能有很多不妥之处,望各位大佬雅正。
公众号:网织青春zcwlgc2019

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 数字20 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读