经典问题

第一个问题
当程序存在多个对象的时候,如何确定这些对象的析构顺序?
单个对象创建时构造函数的调用顺序

调用父类的构造过程
调用成员变量的构造函数(调用顺序与声明顺序相同)
调用类自身的构造函数
析构函数与对应构造函数的调用顺序相反

多个对象析构时
析构顺序与构造顺序相反,比如构造对象A,B,C,析构就是C,B,A

例子:

#include <stdio.h>
class Member
{  
   private:
   const char *ms;
   public:
   Member(const char *s)
   {
     ms = s;
     printf("Member %s create\n",ms);
   }
   ~Member()
   {
      printf("Member %s destroy\n",ms);
   }
};
class Test
{
   private:
   Member mA;
   Member mB;
   public:
   Test():mB("mB"),mA("mA")
   {
      printf("Test()\n");
   }
   ~Test()
   {
      printf("~Test()\n");
   }
};
Member gA("gA");
int main(void)
{
  Test t;
  return 0;
}

结果:

sice@sice:~$ gedit test.cpp
sice@sice:~$ g++ test.cpp 
sice@sice:~$ ./a.out 
Member mC create
Member mA create
Member mB create
Test()
~Test()
Member mB destroy
Member mA destroy
Member mC destroy

毫无疑问首先构造的就是全局对象,因此mC先创建,后面,由于Test类没有父类我们可以忽略上面的第一条,看到第二条,就应该调用成员变量的构造函数,且和声明顺序一样,所以mA,mB被创建,最后创建类自身的构造函数,析构函数顺序反着来,对于栈对象和全局对象,类似于入栈与出栈的顺序,最后构造的对象被最先析构,堆对象的析构发生在使用delete的时候,与delete的使用顺序相关

第二个问题
const关键字能否修饰类的对象,如果可以,有什么特性呢?const成员函数的用法?
1
const关键能够修饰对象
const修饰的对象为只读对象,只读对象的成员变量不允许被改变
只读对象时编译阶段的概念,运行时无效

const成员函数
定义:
Type ClassName::function(Type p)const
const对象只能调用const的成员函数
const成员函数中只能调用cosnt成员函数
const成员函数中不能直接改写成员变量的值

例子:

#include <stdio.h>
class Test
{
   private:
   int mi;
   public:
   int getI();
   Test(int i);
};
Test::Test(int i)
{
  mi = i;
}
int Test::getI()
{
  return mi;
}
int  main()
{
  const Test t(1);
  t.mi = 2;
  return 0 ;
}

结果:

sice@sice:~$ g++ test1.cpp 
test1.cpp: 在函数‘int main()’中:
test1.cpp:5:8: 错误： ‘int Test::mi’是私有的
test1.cpp:21:5: 错误： 在此上下文中
test1.cpp:21:10: 错误： assignment of member ‘Test::mi’ in read-only object

验证了“const修饰的对象为只读对象,只读对象的成员变量不允许被改变”,当t对象调用getI()成员函数时也会报错,“因为const成员函数中只能调用cosnt成员函数”,把getI()改成getI()const,int Test::getI()改成int Test::getI()const,编译可以运行通过,注意const成员函数中不能直接改写成员变量的值

第三个问题
成员函数和成员变量都是隶属于具体对象的吗?
每一个对象拥有自己独立的属性(成员变量),所有的对象共享类的方法(成员函数),方法能够直接访问对象的属性,方法中的隐藏参数this用于指代当前的对象(this里面存储调用当前函数的对象地址)
例子:

#include <stdio.h>

class Test
{
    int mi;
public:
    int mj;
    Test(int i);
    Test(const Test& t);
    int getMi();
    void print();
};

Test::Test(int i)
{
    mi = i;
}

Test::Test(const Test& t)
{
    mi = t.mi;
}
    
int Test::getMi()
{
    return mi;
}

void Test::print()
{
    printf("this = %p\n", this);
}

int main()
{
    Test t1(1);
    Test t2(2);
    Test t3(3);
    
    printf("t1.getMi() = %d\n", t1.getMi());
    printf("&t1 = %p\n", &t1);
    t1.print();
    
    printf("t2.getMi() = %d\n", t2.getMi());
    printf("&t2 = %p\n", &t2);
    t2.print();
    
    printf("t3.getMi() = %d\n", t3.getMi());
    printf("&t3 = %p\n", &t3);
    t3.print();
    
    return 0;
}

结果：

sice@sice:~$ ./a.out 
t1.getMi() = 1
&t1 = 0xbfa735f8
this = 0xbfa735f8
t2.getMi() = 2
&t2 = 0xbfa73600
this = 0xbfa73600
t3.getMi() = 3
&t3 = 0xbfa73608
this = 0xbfa73608

说明了成员函数和普通的函数时不一样的,成员函数有一个隐含的参数,这个参数是一个this指针,this指针指向当前调用的对象,也可以看出成员变量是每个对象独占的,而成员函数是共享的

勇士后卫头盔哥

发布了20 篇原创文章 · 获赞 1 · 访问量 354

私信关注

猜你喜欢