小问题请教

[nizainade]

有下面一段测试代码：
char*pTest=NULL;
char* test()
{
std::string a="abc";
pTest=(char*)a.c_str();
// char*p="abc";
// pTest=p;

return pTest;
}
void main()
{
test();
assert(pTest!=NULL);
printf("%s",pTest);
}

程序输出乱码，但是 把
std::string a="abc";
pTest=(char*)a.c_str();
注释掉，把下面本来的注释去掉就能显示正常，请问为什么

[白乔]

to 12搂：

试试

	char * cp1 = "abc";
	char * cp2 = "abc";
	char cp3[] = "abc";
	char cp4[] = "abc";
	
	cout << (void *) cp1 << endl;
	cout << (void *) cp2 << endl;
	cout << (void *) cp3 << endl;
	cout << (void *) cp4 << endl;

--------我是分隔线--------我是分隔线--------我是分隔线--------

学标准的、全面的C++
写笨笨的、健壮的代码
做风趣的、谦逊的程序员

--------《标准C++开发入门与编程实践》
http://books.vcer.net/stdcpp

[Mnky]

char tmp[20]="abc" 是定义一个数组，然后让他的值等于"abc"；
char *tmp="abc" 是在常量区开辟一个"abc"常量，然后将tmp指针指向该常量。
也就是说，前者的"abc"是复制的，后者的"abc"是原版的。

同样，std::string a="abc"; pTest=(char*)a.c_str(); 并不是将 pTest直接指向了"abc"，而是先将"abc"复制给了string a，使得a的值为"abc"，然后用pTest去指向a的值。所以如果a不存在了，pTest既然就不对了。
而 char*p="abc";pTest=p; 之后，p和pTest都直接指向常量区的原版"abc"，所以出了test()函数作用区，对常量区依然没有影响。

[nizainade]

那是不是说，只有指针通过指针才能访问常量内存区域

[nizainade]

那是不是说，只有通过指针才能访问常量内存区域

[白乔]

可以这个理解吧

其实是：一个是直接赋值，一个是拷贝赋值

[nizainade]

那如果更改一下：
int *pTest=NULL;

void test()
{
int a=2;
pTest=&a;
}
void main()
{
test();
assert(pTest!=NULL);
std::cout<<(*pTest);
}
上面，int a=2；a并不是常量，那为什么main中pTest也能输出2，在test中a的内存肯定释放了的啊

[pengxn]

int *pTest=NULL;

void test()
{
int a=2;
pTest=&a;
}
void main()
{
test();
assert(pTest!=NULL);
std::cout <<(*pTest);
}
-----------
按楼上的代码我编译了下,执行结果输出为0.

关于空间释放的问题,我觉得应该还和编译器,环境有关系.

个人觉得:
不过还是觉得这样的写法本身就存在野指针的问题,不应该这样写,否则获得的结果也是不确定的

[Mnky]

回会18楼，a确实释放了，只能说你运气不错，释放了，但是数值还没有被破坏。其实已经是非法的了，得到2也不能说明什么。

[wumuyishu]

不管注释不注释两种做法都是不对 都是野指针的问题
不注释后 输出正确只是 因为"abc",是一个常量字符串 编译器放的位置是内存中特定的区域,是确定的不会被改变
而string 里的是在栈上申请空间来放置的 函数结束后 空间被释放了

[ssdx]

char *p = "abc" abc在常量区定义，编译时分配，运行时地址固定。

std::string p = "abc" 运行时，栈上分配，函数结束后，出栈，野指针。

[业余的CODER]

char*pTest=NULL;
char* test()
{
std::string a="abc";
pTest=(char*)a.c_str();
// char*p="abc";
// pTest=p;
return pTest;
}
void main()
{
test();
//test函数执行结束后，函数内分配的string a="abc"内存释放，pTest成为野指针。 assert(pTest!=NULL);
printf("%s",pTest);
}

[pengxn]

std::string a="abc";
这个变量的作用域只在 test() 函数之中,是一个临时变量.而pTest指向这个临时变量,
printf("%s",pTest)的时候pTest已经变成一个野指针了.

[pengxn]

string 这个类在析造的时候会释放空间,所以pTest的内容会为空.

[Mnky]

你用pTest=p，那么pTest直接指向了"abc"，不管test()作用于如何，都不会影响。
但是pTest=(char*)a.c_str();的话，pTest是和a相关的，a出了test()就不存在了，所以pTest也就无效了。

[pengxn]

Mnky 理解错楼主的意思了.

楼主原话

std::string   a="abc"; 
        pTest=(char*)a.c_str(); 
注释掉，把下面本来的注释去掉就能显示正常，请问为什么

意思是楼主可以正常使用的代码是

char*   test() 
{ 
        std::string   a="abc"; 
        pTest=(char*)a.c_str(); 
        char*p="abc"; 
        pTest=p; 

        return   pTest; 
} 

==================

而且"你用pTest=p，那么pTest直接指向了"abc"，不管test()作用于如何，都不会影响。" 这个说法也是错误的
测试了一下

char*pTest=NULL; 
char*   test() 
{ 
        std::string   a="abc"; 
        pTest=a.c_str(); 
		cout<<"pTest1 = "<<pTest<<endl;
        return   pTest; 
} 
int   main() 
{ 
        test(); 
        cout<<"1"<<endl;
        if(pTest==NULL)
        	cout<<"2"<<endl;
        assert(pTest!=NULL); 
       cout<<"pTest = "<<pTest<<endl;
} 

结果为

$ SS
pTest1 = abc
1
pTest = 

[Mnky]

To pengxn:
1、我认为是你理解错了；
2、如果你想批驳我的关于pTest=p的观点，至少也要用到这一句吧。。。

[wjlsmail]

只能这样解释：

char * pcStr = "abc"; // "abc" 编译时常量区分配
string str = "abc"; // "abc" 运行时栈上分配

[skefer]

首先，
char*p="abc"; // "abc" 编译时常量区分配
所以能输出期望的结果，但是这样的设计本身有问题
因为test内的“abc”是常量字符串，位于静态存储区，
它在程序生命期内恒定不变。无论什么时候调用test（），
它返回的始终是同一个“只读”的内存块



程序输出乱码时
std::string a="abc";
pTest=(char*)a.c_str();
test函数执行结束后，函数内分配的string a="abc"内存释放，pTest成为成为野指针。
而这个时候pTest不是NULL ，pTest成为野指针是指它指向的内存是没用的，不是把pTest变成NULL所以
assert(pTest!=NULL) //并不能判别pTest是否为野指针
结果输出野指针指向的乱码。

[herman~~]

栈作用域

[kukumouse]

char*p="abc"; //字符串在编译时分配在静态区,退出test()后内容还在.
std::string a="abc";//因为string是一个类,它的操作符"="是将"abc"拷贝到一个堆空间里面保存,当test()退出后,a的空间被释放了,所以该值已经失去意义,不可靠了.