一道 C++ 关于野指针和作用域的问题

前言：

前些天问了问了一道题：

http://home.cnblogs.com/q/27511/ 

结果网上的评价 都还是理解有点不对，这里记录下我试验的结果以及解决方案

1.原题如下：问题是当p离开作用域时，不是应该p变成野指针么，为什么test函数输出依然正确？

#include <iostream>
using namespace std;
class A{
    public:
    virtual void func(){ cout << "A func()" << endl;}
};
void test(){
    A* p;
    {
        A a;
        p = &a;
    }
    p->func();
}
int main()
{
    test();
    return 0;
}

结果输出 A func()　　

如下回答：

1. A的这个方法是关键。。

因为这个方法内没有访问A的任务东东。也就是没有访问this指针。因此调用有效。

如果方法中有访问A的字段就不行了。。

这是不对的，下面的代码访问到了this指针，结果依然是输出a_i值

#include <iostream>
using namespace std;
class A
{
    private:
    int a_i;
    public:
    void func(){ cout << "A:a_i " << this->a_i << endl;}
    A(int i){this->a_i = i;}
};
void test(){
    A* p;
    {
        A a(5);
        p = &a;
    }
    p->func();
}
int main()
{
    test();
    return 0;
}

输出为A a_i 5　　

将结果换成指针的生成方式换成new，也不行,没有什么本质区别

class A
{
    private:
    int a_i;
    public:
    void func(){ cout << "A:a_i " << this->a_i << endl;}
    A(int i){this->a_i = i;}
};
void test(){
    A* p;
    {
        p = new A(3);
    }
    p->func();
}
int main()
{
    test();
    return 0;
}

　　输出为A a_i 5　

 关于作用域：

作用域：a.func();已经出了作用域
#include <iostream>
using namespace std;
class A{
    private:
    int a_i;
    public:
    void func(){ cout << "A:a_i " << this->a_i << endl;}
    A(int i){this->a_i = i;}
};
void test(){
    A* p;
    {
        A a(5);
        p = &a;
    }
    a.func();
    p->func();
}
int main()
{
    test();
    return 0;
}

　　结果：编译不过去

是不是野指针的问题，答案肯定是，看下面的

class A
{
    private:
    int a_i;
    public:
    void func(){ cout << "A:a_i " << this->a_i << endl;}
    A(int i = 0){this->a_i = i;}
};
int main()
{
    A* p;//野指针
    p->func();
    return 0;
}

　　A 没有初始化，但是结果是： 

     A:a_i 0 

  这几天也在复习C++，想了想，其实，在C++ 对象模型 中 有这么一段话：

  类的非虚方法并不会存在于对象的内存布局中，实际上C++编译器将方法转化为全局函数，上面的会转化为： A_func_xxx ()，而对象的指针是作为第一个参数被隐式的传递给了该函数，所以上面的p->func(); 调用的是全局函数A_func_xxx ()，p作为this指针隐式的传递给了func()函数，所以结果是正确的

下面有一个这样的回复：

#include <iostream>
using namespace::std;
class A
{
    private:
    int a_i;
    public:
    void func(){ cout << "A:a_i " << this->a_i << endl;}
    A(int i){this->a_i = i;}
};
void test(){
    A* p;
    {
        p = new A(3);
        delete p;
    }
    A* b=new A(23);
    cout << "==!!" << endl;
    p->func();
}
int main()
{
    test();
    return 0;
}

　　 A* b=new A(23); 重新使用了先前分配的内存

下面的回复有一个关于堆栈的问题，一直以为自己懂了：

#include <iostream>

using namespace std;

//指针的地址是在栈中（首地址除外），但是指针指向的内容却在堆中，
//所以并没有被清除

char* get_str()
{
    char* str = {"abcd"};
     return str;
}
//栈里面的变量都是临时的。当前函数执行完成时，
//相关的临时变量和参数都被清除了,所以返回的指针指向的已经是随机的了
//但是str[]首地址被当成指针来处理，存放在堆中。
char* get_str2()
{
    char str[] = {"abcd"};
     return str;
}
int main(int argc, char* argv[])
{
    char* p = get_str();
    cout << *p << endl;
    cout << *(p+1) << endl;
    cout << p << endl;
    cout << "========================" << endl;

    char *p2 = get_str2();
    //第1次执行 *p2的时候，由于p2指针的首地址被返回了，还是可以取到*p2的内容的
    /*
      可以试试取*(p2+1),也是可以取到的
    */
    cout << *p2 << endl;
   
    //第一次调用*p2的时候还是有数据的，但是第2次就没有了，
    //说明cout之后指针已经被破坏了
    cout << *p2 << endl;
    cout << *(p2+1) <<endl;
    cout << *p2 << endl;
    cout << p2 << endl;
     return 0;
}

　　但是这个：答案是可以正确的运行，因为是常量字符串，存储在静态内存区中，返回没事，所以说，还得看清题啊 

#include <iostream>
#include <stdio.h>
using namespace std;

char *fun(void)
{
char *p="hello";
return p;
}
int main(void)
{
char *s;
s=fun();
printf("%s\n",s);
}