void main()
{
char *str1={"Hello"};
char *str2={"Hello World"};
char * const ptr1 =str1 ;
*ptr1 ='A';
printf("%c \n",*ptr1);
}
void main()
{
char str1[]={"Hello"};
char str2[]={"Hello World"};
char * const ptr1 =str1 ;
*ptr1 ='A'
printf("%c \n",*ptr1);
}
为什么第一个不能执行 第二个能够执行? 区别? 通宵等大大解答!
21 个解决方案
#1
#2
第一个字符串位于常量区,不能修改
#3
++
正解
#4
++
char* str = "abc"; // 这样的写法,str是常量,不能被修改
char str[] = "abc"; // 这样的写法,str是变量,可以被修改
#5
在我机子上,两种都能编译通过
#6
runtime error!
#7
我用的wintc,确实是通过了……
#8
编译是可以通过,不能执行。2L正解。
#9
4L说的对,就是字符串常量的问题。
第一个程序那样写是字符串常量;
第二个程序就表示数组初始化了。
第一个程序那样写是字符串常量;
第二个程序就表示数组初始化了。
#10
楼上的都说对着
希望楼主明白
#include<stdio.h>
void main()
{
char *str1={"Hello"};//字符串放在常量区
char *str2={"Hello World"};//同上
char * const ptr1 =str1 ;//ptr1是个指针常量 那么指针的地址不可在改变
*ptr1 ='A';//此处企图改变常量区的字符串 内地址可读 但地址的内容不可改 错误
printf("%c \n",*ptr1);//输出的应该是字符创常量的第一个字符H
}
void main()
{
char str1[]={"Hello"}; //这个则不一样了,字符其实是赋给了字符数组了
char str2[]={"Hello World"}; //同上 就是数组里面放的是字符而已
char * const ptr1 =str1 ; //ptr1是指针常量 指针的值不可改 但是所指的对象可以改
*ptr1 ='A'//改变得就是变量的存储内容 可行
printf("%c \n",*ptr1); //输出为替换后的字符A
}
希望楼主明白
#11
char *str1={"Hello"}; //str1在栈中 ,"Hello"在常量区域中, { }这个东西,用法第一次遇到,呵呵
char *str2={"Hello World"};
char * const ptr1 =str1 ; //pstr1在栈中,用了const修饰它,说明它是个常量,即:它只能指着一个东西,不能指着其他了。。。。。
*ptr1 ='A'; //ptr1和str1指着常量区域,所以不能 修改,常量去的内容是不能修改的。
char *str2={"Hello World"};
char * const ptr1 =str1 ; //pstr1在栈中,用了const修饰它,说明它是个常量,即:它只能指着一个东西,不能指着其他了。。。。。
*ptr1 ='A'; //ptr1和str1指着常量区域,所以不能 修改,常量去的内容是不能修改的。
#12
char *str1={"Hello"};
char *str2={"Hello World"};
char * const ptr1 =str1 ;
这个位于文字常量区,不能修改的
char str1[]={"Hello"};
相当于数组,数组当然可以随便改里面的元素的值了
char *str2={"Hello World"};
char * const ptr1 =str1 ;
这个位于文字常量区,不能修改的
char str1[]={"Hello"};
相当于数组,数组当然可以随便改里面的元素的值了
#13
#include<iostream>
using namespace std;
int main()
{
char str1[]={"Hello"}; //str1是个数组名,这数组名,它的内容在栈中,内容可以修改的。
char str2[]={"Hello World"};
char * const ptr1 =str1 ;
*ptr1 ='A';
cout<<ptr1; //Aello World 输出结果为这个
return 0;
}
以上代码可以通过。。。。。。。。。
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
楼主看这里, str1="nihao"; 如果写成这样,就是错误的。。。 str1是数组名,数组名不能这样用
如果要修改其内容,要么借助指针,要么借助strcpy(str1,"nihao")这个函数来修改。
你的方法是借助指针来完成对数组内容的修改
using namespace std;
int main()
{
char str1[]={"Hello"}; //str1是个数组名,这数组名,它的内容在栈中,内容可以修改的。
char str2[]={"Hello World"};
char * const ptr1 =str1 ;
*ptr1 ='A';
cout<<ptr1; //Aello World 输出结果为这个
return 0;
}
以上代码可以通过。。。。。。。。。
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
楼主看这里, str1="nihao"; 如果写成这样,就是错误的。。。 str1是数组名,数组名不能这样用
如果要修改其内容,要么借助指针,要么借助strcpy(str1,"nihao")这个函数来修改。
你的方法是借助指针来完成对数组内容的修改
#14
恩,基本明白是怎么回事了。。。谢谢各位!
#15
char *str1={"Hello"}; //str1在栈中 ,"Hello"在常量区域中, { }是什么用法?正常的不是char *str1="Hello";么;
#16
"hello"其实是放在重定位文件的.rodata中,read only
汇编代码如下:
.section .rodata
.LC0:
.string "hello world\n"
指针指向它,而它是不可修改的。编译应该都没法通过。
汇编代码如下:
.section .rodata
.LC0:
.string "hello world\n"
指针指向它,而它是不可修改的。编译应该都没法通过。
#17
++
#18
受益了!再请问为何用字符指针变量对数组初始化的内容就放在常量区,而用数组存储字符串就放在变量区呢?
#19
指针只是指向常量字符串的地址,不能修改常量。数组分配内存并把字符串拷贝到相应内存中,所以可以修改
#20
是的,一般是没有{} 的,
一般是这样用:char*str1="hello" ;
如果在mfc 中,可以这样用: TCHAR* str1=_T("hello"); //说远了,估计你没学过mfc
一般是这样用:char*str1="hello" ;
如果在mfc 中,可以这样用: TCHAR* str1=_T("hello"); //说远了,估计你没学过mfc
#21
这个问题,你问C++创始人去,
记住就行了。。。。
记住就行了。。。。
#1
#2
第一个字符串位于常量区,不能修改
#3
++
正解
#4
++
char* str = "abc"; // 这样的写法,str是常量,不能被修改
char str[] = "abc"; // 这样的写法,str是变量,可以被修改
#5
在我机子上,两种都能编译通过
#6
runtime error!
#7
我用的wintc,确实是通过了……
#8
编译是可以通过,不能执行。2L正解。
#9
4L说的对,就是字符串常量的问题。
第一个程序那样写是字符串常量;
第二个程序就表示数组初始化了。
第一个程序那样写是字符串常量;
第二个程序就表示数组初始化了。
#10
楼上的都说对着
希望楼主明白
#include<stdio.h>
void main()
{
char *str1={"Hello"};//字符串放在常量区
char *str2={"Hello World"};//同上
char * const ptr1 =str1 ;//ptr1是个指针常量 那么指针的地址不可在改变
*ptr1 ='A';//此处企图改变常量区的字符串 内地址可读 但地址的内容不可改 错误
printf("%c \n",*ptr1);//输出的应该是字符创常量的第一个字符H
}
void main()
{
char str1[]={"Hello"}; //这个则不一样了,字符其实是赋给了字符数组了
char str2[]={"Hello World"}; //同上 就是数组里面放的是字符而已
char * const ptr1 =str1 ; //ptr1是指针常量 指针的值不可改 但是所指的对象可以改
*ptr1 ='A'//改变得就是变量的存储内容 可行
printf("%c \n",*ptr1); //输出为替换后的字符A
}
希望楼主明白
#11
char *str1={"Hello"}; //str1在栈中 ,"Hello"在常量区域中, { }这个东西,用法第一次遇到,呵呵
char *str2={"Hello World"};
char * const ptr1 =str1 ; //pstr1在栈中,用了const修饰它,说明它是个常量,即:它只能指着一个东西,不能指着其他了。。。。。
*ptr1 ='A'; //ptr1和str1指着常量区域,所以不能 修改,常量去的内容是不能修改的。
char *str2={"Hello World"};
char * const ptr1 =str1 ; //pstr1在栈中,用了const修饰它,说明它是个常量,即:它只能指着一个东西,不能指着其他了。。。。。
*ptr1 ='A'; //ptr1和str1指着常量区域,所以不能 修改,常量去的内容是不能修改的。
#12
char *str1={"Hello"};
char *str2={"Hello World"};
char * const ptr1 =str1 ;
这个位于文字常量区,不能修改的
char str1[]={"Hello"};
相当于数组,数组当然可以随便改里面的元素的值了
char *str2={"Hello World"};
char * const ptr1 =str1 ;
这个位于文字常量区,不能修改的
char str1[]={"Hello"};
相当于数组,数组当然可以随便改里面的元素的值了
#13
#include<iostream>
using namespace std;
int main()
{
char str1[]={"Hello"}; //str1是个数组名,这数组名,它的内容在栈中,内容可以修改的。
char str2[]={"Hello World"};
char * const ptr1 =str1 ;
*ptr1 ='A';
cout<<ptr1; //Aello World 输出结果为这个
return 0;
}
以上代码可以通过。。。。。。。。。
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
楼主看这里, str1="nihao"; 如果写成这样,就是错误的。。。 str1是数组名,数组名不能这样用
如果要修改其内容,要么借助指针,要么借助strcpy(str1,"nihao")这个函数来修改。
你的方法是借助指针来完成对数组内容的修改
using namespace std;
int main()
{
char str1[]={"Hello"}; //str1是个数组名,这数组名,它的内容在栈中,内容可以修改的。
char str2[]={"Hello World"};
char * const ptr1 =str1 ;
*ptr1 ='A';
cout<<ptr1; //Aello World 输出结果为这个
return 0;
}
以上代码可以通过。。。。。。。。。
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
楼主看这里, str1="nihao"; 如果写成这样,就是错误的。。。 str1是数组名,数组名不能这样用
如果要修改其内容,要么借助指针,要么借助strcpy(str1,"nihao")这个函数来修改。
你的方法是借助指针来完成对数组内容的修改
#14
恩,基本明白是怎么回事了。。。谢谢各位!
#15
char *str1={"Hello"}; //str1在栈中 ,"Hello"在常量区域中, { }是什么用法?正常的不是char *str1="Hello";么;
#16
"hello"其实是放在重定位文件的.rodata中,read only
汇编代码如下:
.section .rodata
.LC0:
.string "hello world\n"
指针指向它,而它是不可修改的。编译应该都没法通过。
汇编代码如下:
.section .rodata
.LC0:
.string "hello world\n"
指针指向它,而它是不可修改的。编译应该都没法通过。
#17
++
#18
受益了!再请问为何用字符指针变量对数组初始化的内容就放在常量区,而用数组存储字符串就放在变量区呢?
#19
指针只是指向常量字符串的地址,不能修改常量。数组分配内存并把字符串拷贝到相应内存中,所以可以修改
#20
是的,一般是没有{} 的,
一般是这样用:char*str1="hello" ;
如果在mfc 中,可以这样用: TCHAR* str1=_T("hello"); //说远了,估计你没学过mfc
一般是这样用:char*str1="hello" ;
如果在mfc 中,可以这样用: TCHAR* str1=_T("hello"); //说远了,估计你没学过mfc
#21
这个问题,你问C++创始人去,
记住就行了。。。。
记住就行了。。。。