问一个超级简单的问题

[mm1543]

一个字符串拷贝函数如下：
char * strcpy1(char * strDest, const char * strSrc)
{
if((strDest==NULL) || (strSrc ==NULL))
return NULL;
if(strDest==strSrc)
return strDest;
char *address = strDest;
while(*strSrc!= '\0')
{
*strDest=*strSrc;
strDest++;
strSrc++;
}
*strDest=*strSrc;
return address ;
}

现在主程序中如下的调用是正确的：
const char * p="asdfqwer";
char q[1]；
char *rtn=strcpy1(q,p);
cout << rtn;

但是这样为什么不行呢？
char * p="asdfqwer";
char q=“yyy”；char *rtn=strcpy1(q,p);
cout << rtn;

还有，strcpy1（）函数的第二个参数是一个指向常量字符串的指针，但是为什么如下调用也可以呢？
char * p="asdfqwer";//没有const
char q[1]；
char *rtn=strcpy1(q,p);
cout << rtn;

[wangguilin]

你所定义的那个q就不对
因为单纯的char类型只能表示一个字符，而不能表示字符串

[zhuwanglove]

char q=“yyy”, //q是一个字符,类型不符,编译不过
还有，strcpy1（）函数的第二个参数是一个指向常量字符串的指针，但是为什么如下调用也可以呢？
const char * strSrc是参数,是实参的一个拷贝.const 说明不会改变实参.

[OenAuth.Core]

但是这样为什么不行呢？
char * p="asdfqwer";
char q=“yyy”；char *rtn=strcpy1(q,p);
cout < < rtn;

q不能那样定义，只能char *q="yyy";

[OenAuth.Core]

还有，strcpy1（）函数的第二个参数是一个指向常量字符串的指针，但是为什么如下调用也可以呢？
char * p="asdfqwer";//没有const
char q[1]；
char *rtn=strcpy1(q,p);
cout < < rtn;

strcpy1(q,p)中运行的只是p的一个COPY，加const说明不能修改实参。

[wolfdog1111]

up

[我看你有戏]

#include "iostream"
using namespace std;
char * strcpy1(char * strDest, const char *  strSrc) 
{ 
	if((strDest==NULL) || (strSrc ==NULL)) 
		return NULL;    
    if(strDest==strSrc) 
		return strDest;  
    char *address = strDest;                                  
	while(*strSrc!= '\0') 
	{ 
		*strDest=*strSrc; 
		strDest++; 
		strSrc++; 
	} 
	*strDest=*strSrc; 
	return address ;  
} 

void main()
{
	char * p="asdfqwer"; 
	char *q="yyy";
	char *rtn = strcpy1(q,p);	
	cout << rtn; 
}

//即使是这样，编译通过，执行报错

//原因是，char *q="yyy";这样定义的话  q指向的是内存的常量区域，数据是只读的

//所以拷贝的时候就会出错

[nolatestudy]

LZ先要理解好这句：char * p="asdfqwer";
这句定义了一个指针，该指针指向常量区域，故不能通过P去改变该区域的数据；

其次是对const的理解，不能简单地认为const修饰的代表常量，应该理解为作用域内“只读”。
非const可以作为函数的const参数，但const对象不能作为函数的非const参数，因为不存在const->非const的隐式转换。
具体的自己写个简单程序试试再去理解容易明白。

[huatiezhou]

支持楼上

[zgy1353246]

6楼UP！！！

[mm1543]

[Quote=引用 6 楼 henry3695 的回复:]
C/C++ code
#include "iostream"
using namespace std;
char * strcpy1(char * strDest, const char * strSrc)
{
if((strDest==NULL) || (strSrc ==NULL))
return NULL;
if(strDest==strSrc)
return strDest;
char *address = strDest;
while(*strSrc!= '\0')
{
*strDest=*strSrc;
strDest++;
str…
[/Quote]



不好意思，我写的时候不小心，我的char q=“yyy”；应该是char * q=“yyy”；

[pusshi]

[Quote=引用楼主 canny1543 的帖子:]
一个字符串拷贝函数如下：
char * strcpy1(char * strDest, const char * strSrc)
{
if((strDest==NULL) || (strSrc ==NULL))
return NULL;
if(strDest==strSrc)
return strDest;
char *address = strDest;
while(*strSrc!= '\0')
{
*strDest=*strSrc;
strDest++;
strSrc++;
}
*strDest=*strSrc;
return address ;
}

现在主程序中如下的调…
[/Quote]还超级简单,,太难了.....Y根看不懂是什么东西...............

[yang1216]

企图修改常量区数据。

[mm1543]

谢谢各位的回复，尤其是7楼的，但是我还有一个疑问。
7楼说，
char * p="asdfqwer";
这句定义了一个指针，该指针指向常量区域，故不能通过P去改变该区域的数据；
那么char * p="asdfqwer" 和const char * p="asdfqwer" 两者都不能进行 *p="？？？"这样的操作，那么两者有什么区别呢？

[我看你有戏]

//一个指向char类型的const对象指针，p不是常量,我们可以修改p的值，
//使其指向不同的char，但是不能通过p指针去修改它所指的值
const char *p;
char c1='a';
char c2='b';
p=&c1;//ok
p=&c2;//ok
//*p=c1;//error


char const *p ; //跟const char *p;差不多的
char c1 = 'a';
char c2 = 'b';
p = &c1;
p = &c2;
//*p = 'b';//error 就是不能通过p指针去修改它所指的值
c1 = 'c';


//如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。
char c1 = 'a';
char c2 = 'b';
char * const p = &c2;
*p = c1;
*p = c2; //通过p指针去修改它所指的值
//p = &c1;//error p本身是常量所以不能修改


char c1 = 'a';
char c2 = 'b';
const char * const p = &c1; //这种是地址及指向对象都不能修改。
char n = *p;
//*p = c2;//error
//p = &c1;//error