C++成员函数作用域问题

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#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值

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#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，也不行,没有什么本质区别

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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　

 关于作用域：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

作用域：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; }

　　结果：编译不过去

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14

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;
}

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