第一个是不是 memset( this , 0 , sizeof( myClass ) ) ;这里有问题。不能把整个类的内存都弄成零吧；
第二我很少用sting，是不是返回了局部变量

2: 返回的是局部变量

上面说错.
第二题 返回的是 一个 const 指针，指的是 指针不能改变.sz += ".txt"; 改变了指针。
 去掉，程序就正确
#include <string>
inline const char* fun( const char* _pSZ )
{
std::string sz( _pSZ  );
//sz += ".txt";
return sz.c_str();
}

当我没说，实验 失败

第一题  对象中有虚表，你却把它的虚函数指针设为0，动态绑定时就不能调用析构了。
第二题  函数返回时，sz对象要析构，sz.c_str();得到的指针已失效。

昨晚一直回复不了这个问题，csdn挂了。

1,
破坏了virtual table，调用不到~myClass函数指针位置！对象不能正常析构
~myClass()是virtual，那么类在编译的时候会有一个virtual table来存放virtual functions的指针，memset后，指针相当与NULL了，那么就不能析构了！因为找不到析构的函数 

（猪头的程序）
#include <iostream>
using namespace std;
struct myClass
{
int m_a;

myClass(){ memset( this , 0 , sizeof( myClass ) ) ; }
int print(){cout<<m_a<<endl;cout<<sizeof(myClass)<<endl;}
virtual ~myClass(){};
};

int main()
{
myClass x;
x.print();
x.~myClass();
return 0;

} 

2，
返回局部变量！

UPCC兄，你错误的理解了偶得言语。
struct myClass
{
int m_a;

myClass(){ memset( this , 0 , sizeof( myClass ) ) ; }

virtual ~myClass(){};
};
从理论上来讲虚函数表是被清零了，但是依然能够正常析构。

下面的更恐怖：
#include <stdio.h>
#include <iostream>
struct T {
  int m;
  
  virtual ~T() { printf("base dtor\n"); }
};

struct T2 : public T {
  virtual ~T2() { printf( "dvd dtor\n"); }
};

int main() {
  T2 t;
  printf( "&t: %p\n", &t );
  printf( "&t.m: %p\n", &(t.m) );
  memset((int *)(*((int *)&t)),0,4);
  memset(((int *)&t),0,4);
  return 0;
}

1.
struct myClass 
{
        int m_a;
        myClass()
{
unsigned int* position=(unsigned int*)this;
memset( position+1 , 0 , sizeof( myClass )-4 );
}     
        virtual ~myClass(){cout<<"in destructor"<<endl;};
};
这样可以不清虚表把和员变量清0，另问如果虚表被清了虚函数一样能被执行，那虚表还有什么用，请达人解释下虚表工作过程。

2.返回局部变量是没错的，它返回的是const局部变量这点是没有错误的。例如：
const char* fun1()
{
  const char* p = "hello";
  return p;
}

char* fun2()
{
  char buffer[100];
  char* p = buffer;
  sprintf(p,"%s","world");
  return p;
}

void main(void)
{
  printf("%s %s\n",fun1(),fun2());
}
fun2()才是显示不出来的，原因是返回局部变量。
本题错在inline inline函数内不能调用其它函数否则inline无效。

应聘时碰到如下题目，大家发表意见，让我确认一下。

//指出下列代码的错误
//-------------------------------------------------
struct myClass
{
int m_a;

myClass(){ memset( this , 0 , sizeof( myClass ) ) ; }

virtual ~myClass(){};
};

myClass(){ memset( this , 0 , sizeof( myClass ) ) ; }
因为myClass有虚函数,这样清零会将vptr清零,出现违规访问
//-------------------------------------------------

//指出下列代码的错误
//-------------------------------------------------
#include <string>
inline const char* fun( const char* _pSZ )
{
std::string sz( _pSZ  );
sz += ".txt";
return sz.c_str(); //返回局部变量
}

对于第一题,猪头的程序没有用到动态解析t的析构函数的调用
请你用T2 *t=new T2;
delete t;试试(=_=)

int main() {
  T2 t;
  printf( "&t: %p\n", &t );
  printf( "&t.m: %p\n", &(t.m) );
  memset((int *)(*((int *)&t)),0,4);
  memset(((int *)&t),0,4);
  return 0;
}

#include <iostream>

#include <string>

using namespace std;


inline const char* fun( const char* _pSZ )
{
std::string sz( _pSZ  );
sz += ".txt";
return sz.c_str(); //返回局部变量
}

int main()
{
const char *p="sadf",*q;
q=fun(p);
cout<<q;
system("pause");
return 0;

} 
能运行.

#include <stdio.h>
#include <iostream>
struct T {
        T() {printf("&m: %p\n",&m); }  
  virtual ~T() { printf("base dtor\n"); }
  int m;  
};

struct T2 : public T {
  virtual ~T2() { printf( "dvd dtor\n"); }
};

int main() {
  T2* t = new T2; 
  printf( "&t: %p\n", &t );
  printf( "&t.m: %p\n", &(t->m) );
  memset((int *)(*((int *)&t)),0,4);
  memset(((int *)&t),0,4);
  delete t;
  return 0;
} 

test@kf ~/zhangjy/test >> g++ setclasszero.cpp 
test@kf ~/zhangjy/test >> ./a.out 
&m: 0x8049d9c
&t: 0xbfffdff4
&t.m: 0x8049d9c
test@kf ~/zhangjy/test >> 

还真是没调析构，new出来的和在栈上定义的还有这区别？
动态解析t的析构函数 就是delete t;吧 这和在程序结束自动调有什么区别？？

弄错了,Dev-C++下正常.

弱弱的问一句：  
memset((int *)(*((int *)&t)),0,4);
memset(((int *)&t),0,4);
啥意思，这么复杂

清除虚函数表和虚函数指针，我干吗非用new和delete.

第一个,只有是new出来的myClass才会core dump
      因为只有指针才实现动态绑定,在运行的时候寻找函数入口,但是这个时候找不到析构函数地址,core了.编译的时候已经确定了函数地址,和实现代码无关.

第二个
string a = "abcd";
const char * b = fun(a.c_str());
这样的一个调用,将数据已经放入了常量数据区,而且常量数据区的数据在程序的整个运行期间都是有效的.所以认为第二个程序是没有问题的.
假如把const去掉就是错误的了.

第一个写的不漏了一点.
直接定义对象到栈中.编译的时候已经确定了函数地址,和实现代码无关.

返回局部变量！
这是那门子错误啊? 这个回答so不准确了.

int a = 1;
return a; 这个返回局部变量有问题嘛?

而且第一个是没有太大问题的,
所谓破坏虚表,那也是要在继承后才会出现的问题.
而虚表的内容确定是在Test::Test()之后的.
所以,第一个反而不会出问题.

记住那句话的每一个字 "返回局部变量的指针或者引用",没有一个没有用的词汇.

第二个问题在于局部变量的声明周期结束,会dealloc它维护的堆指针而已.
这个是根本的原因.

return sz.c_str(); //返回局部变量
改为return sz.c_str(); //返回局部变量的指针(=_=)
MD死甘草,非要睬别人的尾巴(=_=)



 playmud((猪头流氓)(鄙视老迈)(抵制日货)) ( ) 信誉：100  2006-08-07 09:32:00  得分: 0  
  清除虚函数表和虚函数指针，我干吗非用new和delete.

不是指针或者引用,调用虚拟函数是静态绑定的,不会动态解析(=_=)
不动态解析就不会用到vptr(=_=)
猪哥看来是没有睡醒(=_=)
  
 

改为return sz.c_str(); //返回局部变量的指针(=_=)

sz是局部变量吧 它在return 后就消失了 谁再来管理指针的内容？ 泄露了？

Sammy乱讲...
改为return sz.c_str(); //这个叫返回局部变量的指针?

#include<string>
#include<stdio.h>
const char* fun( const char* _pSZ )
{
std::string sz( _pSZ  );
sz += ".txt";
return sz.c_str();
}

struct node
{
  const char* ptraddress;
  char strcontent[100];
  node* nextnode;
  static unsigned long nodecounter;
};
unsigned long node::nodecounter = 0;
int main()
{
        node* firstnode;
        while(node::nodecounter<50)
        {       
                char dir[100];
                const char* p;
                sprintf(dir,"%d",node::nodecounter);
                node* currentnode = new node;
                currentnode->nextnode = firstnode;
                currentnode->ptraddress = fun(dir);
                strcpy(currentnode->strcontent,currentnode->ptraddress);
                firstnode = currentnode;
                node::nodecounter++;
                printf("%p %s %d\n",firstnode->ptraddress,firstnode->strcontent,node::nodecounter);
        }       
        printf("\n\n"); 
        while(node::nodecounter>0)
        {
                printf("%p %s %s %d\n",firstnode->ptraddress,firstnode->strcontent,
                                        firstnode->ptraddress,node::nodecounter);
                node* currentnode = firstnode;
                firstnode = firstnode->nextnode;
                delete currentnode;
                node::nodecounter--;
        }
        return 1;
} 

记录运行中 const char* fun( const char* _pSZ )这函数的返回地址的值和地址的内容
发现他一直是反回一个地址 所以就不算泄露吧？？
当nodecounter数很大的时后那函数会返回两个地址。。。  神奇啊 

第一个,只有是new出来的myClass才会core dump
      因为只有指针才实现动态绑定,在运行的时候寻找函数入口,但是这个时候找不到析构函数地址,core了.编译的时候已经确定了函数地址,和实现代码无关.

第二个
string a = "abcd";
const char * b = fun(a.c_str());
这样的一个调用,将数据已经放入了常量数据区,而且常量数据区的数据在程序的整个运行期间都是有效的.所以认为第二个程序是没有问题的.
假如把const去掉就是错误的了.
===========================================================================
to jigangwang(wang):
const 类型并不是真正的常量（局部），在整个运行期间有效？

唉，一群高人，自愧不如。

2：由于sz是string类，  函数返回时，sz对象要析构，原本的指针失效了。 进去调试就知道了
并不是 什么局部变量的问题