原文：http://www.haogongju.net/art/1694028






多继承时，父类指针指向子类对象时，父类指向的不是子类开始地址，而是子类中对应父类的结构的类对象的基地址，所以，当多个父类指向同一个子类时，父类的指针值其实是不一样的。




5.观察下面一段代码: 

class ClassA 

{ 

public: 

virtual ~ ClassA(){}; 

virtual void FunctionA(){}; 

}; 



class ClassB 

{ 

public: 

   virtual void FunctionB(){}; 

}; 



class ClassC : public ClassA,public ClassB 

{ 

public: 

}; 

  

ClassC aObject; 

ClassA* pA=&aObject; 

ClassB* pB=&aObject; 

ClassC* pC=&aObject; 



关于pA,pB,pC的取值,下面的描述中正确的是: 

A.pA,pB,pC的取值相同.               B.pC=pA+pB 

C.pA和pB不相同                      D.pC不等于pA也不等于pB




这个是多重继承的问题。在《Thinking in C++》第二卷的363页看到重复子对象这部分的内容，明白了怎么回事。

以上两个基类均含有虚函数，故其大小至少有一个虚函数表的指针大小，结构大概是这样的：



ClassA类数据成员
ClassB类数据成员
ClassC类其他数据成员


可以看出对象aObject以ClassA子对象开头，然后是ClassB子对象部分，最后的部分来自ClassC类本身。ClassC的对象既是一个ClassA也是一个ClassB。

故aObject可以向上类型转换到两者中任何一个基类型。




当向上类型转换为ClassA时，结果指针指向ClassA子对象部分，刚好在ClassC对象的开始位置，所以地址pA和pC是相同的。

当向上类型转换到ClassB时，结果指针必须指向ClassB子对象所在的实际位置，因为类ClassB并不知道有关ClassC的事情。

所以上题的答案应为C。




但是这个地方有个好玩的现象：

如果添加如下代码：cout<<"pC==pB?"<<boolalpha<<(pC==pB)<<endl;

则返回值永远都是true，尽管他们的地址输出的时候并不相同。因为pC在pC==pB的过程中被隐式转换为ClassB*，以使得比较有意义。





基类子类在内存中的存储



class a 

{
public: 

int aa
}; 


class b:public a 

{
public: 

int bb; 

} 

从内存的来看 

如a 

－－－－－－－－－| 

|占一个int数据大小--| 

|----（aa数据）------| 

|－－－－－－－－－ 

而b则是 

－－－－－－－－－|－－－－－－－－－ 

|占一个int数据大小--|占一个Int数据大小--| 

|从a中继承而来------|---（bb数据----------| 

|－－－－－－－－－－－－－－－－－－ 

当定义一个基类类型的指针时 

a *p;这时，这个指针指向的是a类型的数据 

当p指针指向派生类的时候，因为p是a类型的指针，所以*p只解释为a类型数据的长度，即 

————————－|－－－－－－－－－ 

|占一个int数据大小--|占一个Int数据大小--| 

|从a中继承而来------|-----（bb数据)-------| 

|－－－－－－－－－－－－－－－－－－ 

|------------|------------| 

|-p只指向这个区域_--| 


因此，当基类的指针（P）指向派生类的时候，只能操作派生类中从基类中继承过来的数据。 

指向派生类的指针，因为内存空间比基类长，会导致严重了后果，所以不允许派生类的指针指向基类。而基类的指针可以指向派生类。 


C++的多态性能解决基类指针不能操作派生类的数据成员的问题。
 
用C++比较好说明白:       

  1:指针的可访问性是由指针的定义决定的,比如说用BaseClass定义的指针,可访问的范围就是BaseClass的内存区域       

  2:允许用一个指向基类的指针指向派生类,由于被指向的对象的内存空间大于指针的可访问空间,所以这种向上映射是安全的       

  3:对象在调用虚函数的时候,是调用父类的函数还是调用派生类的函数,是和对象的类型有关的,比如说一个派生类B,其父类是A,则B的对象调用父类中被声明为VIRTUAL的函数时,被B   所OVERRIDE的函数调用的是B里的函数,而B没有OVERRIDE的函数调用的是基类里的函数 

代码如下：




#include <iostream>

using namespace std;

 

int _tmain(int argc, _TCHAR* argv[])

{

 

    char str1[] = "abc";

    char str2[] = "abc";

    const char str3[] = "abc";

    const char str4[] = "abc";

 

    const char * str5 = "abc";

    const char * str6 = "abc";

 

    char * str7 = "abc";

    char * str8 = "abc";

 

    cout<<boolalpha<<(str1 == str2) <<endl; //false

    cout<<boolalpha<<(str3 == str4) <<endl;//false

    cout<<boolalpha<<(str5 == str6) <<endl;//true

    cout<<boolalpha<<(str7 == str8) <<endl;//true

 

    

    return 0;

}




原因：




5、6、7、8是字面值常量，存放在代码区，是不能修改的，“abc”本身就是一个地址，然后你在栈区定义了四个指针都是指向同一个地址，

指针比较的时候比较的是指针存放的地址，而不是指针本身的地址，当然5、6、7、8都是一样的值。

同时字符数组呢，是存在栈区，四个数组变量，每个变量比较的都是数组的首地址，四个不同的变量当然地址不一样啊。

1，智能指针
2，在使用时，进行地址判断是否指向同一地址。

1，问题
　　写代码的时候遇到一个问题，在方法类里面有个成员变量IplImage* resultImageToDisp,在主函数里面有个局部变量IplImage* resultImage,我需要将resultImageToDisp赋值给resultImage，但只是浅拷贝，就是说resultImageToDisp和resultImag两个图像指针指向了同一内存，主函数结束时按惯例使用cvReleaseImage(&resultImage)，但是在退出函数体时候调用方法类的析构函数，此析构函数也存在一个cvReleaseImage（&resultImageToDisp），这样就造成同一内存释放两次报错。本来简单以为在析构时添加一个if(resutlImageToDisp!=NULL)判断语句就可以解决问题，可是还是报错。那么问题来了，NULL的作用是什么，此处添加什么判断语句可以解决问题？
2，抽象

char *c1,*c2;
c1=new char[10];
c2=c1;
delete c1;
if(/*    c2指向的内存空间没有被释放    */)
{
delete c2;
}

　　该问题抽象成以上一段代码，即寻找if判断语句。
3，思路
　　首先，我想到的是判断指针是否为NULL。由于没能真正理解NULL的作用，想当然认为判断指针是否为NULL，就是判断该指针指向的内存是否为0，这是错误的理解。经过测试，我对同一指针加上NULL判断可以通过，如以下代码。

if (ROIImageUnsmoothed!=NULL)
{
   cvReleaseImage(&ROIImageUnsmoothed);
}
if (ROIImageUnsmoothed!=NULL)
{
   cvReleaseImage(&ROIImageUnsmoothed);
}

　　

resultImage=resultImageToDisp;
cvReleaseImage(&resultImage);
if (resultImageToDisp!=NULL)
{
    cvReleaseImage(&resultImageToDisp);
}

 
　　第一次if成立，第二次不成立，代码完全没问题。而对于双指针指向同一内存却报错，说明，NULL只是判断指针本身，而不是它的内存。
　　查阅资料才明白，释放内存，如free(),deleate()，只是做了一件事情：斩断指针变量与这块内存的关系。（我觉得应该是将这块内存交还给系统，不再供程序使用）free函数就是把这块内存和指针之间的所有关系斩断。从此指针和那块内存之间再无瓜葛。至于指针变量本身保存的地址并没有改变，但是它对这个地址处的那块内存却已经没有所有权了。那块被释放的内存里面保存的值也没有改变，只是再也没有办法使用了。更斩草除根的办法是释放后马上悬空地址，即将指针置为NULL：将指针保存的地址清除，使其不指向任何内存。
　　这样可以解释，opencv的cvReleaseImage函数，一定包括释放内存和指针悬空两个过程。释放掉resultImage后，该指针指向的内存已经不存在，但是并不影响resultImageToDisp，它任然是一个非NULL的指针，所以if判断语句会失败，而且它的指向内存已经不存在，所以再次释放会报错。
　　最后，再次查阅资料，发现没有什么好的方法可以处理，囧。。。
4，收获
　　养成好的习惯，指针变量创建时初始化，要么将指针设置为NULL，要么让它指向合法的内存。
　　指针指向的内存被释放后，紧接着将指针置为NULL。
　　别用两个指针指向同一内存这种邪恶的东西。
参考：
　　http://bbs.csdn.net/topics/80162678
　　http://www.cnblogs.com/haore147/p/3647437.html
转载于:https://www.cnblogs.com/yssongest/p/4608878.html