字符和指针编译的区别
Ⅰ c语言 char 字符数组 和 字符指针 作为 函数参数 的区别
在C语言中，数组作为参数，进行传递时，传递的是指针 ，换句话说，字符数组作为参数，进行传递时，传递的是字符数组的起始地址，相当于一个字符指针，两者没有区别。比如下面的代码：
#include<stdio.h>
voidf1(char*s){printf("%s ",s);}
voidf2(charsa[]){printf("%s ",sa);}
intmain()
{
charrsa[]="worldhello";
f1(rsa);
f2(rsa);
return0;
}
Ⅱ C语言中字符串数组与字符指针数组有什么区别怎么用
我认为：char a [11] = "I love you"; // 注意\0
编译器将string放在栈中。 a是一个地址常量，它指向string的第一个字节。
char * b = "I miss you";
在栈中分配一个指针（一个指针在栈中被分配4个字节），在堆中分配一个string，将指针指向string。
补充：一个string，在内存中存放的时候，编译器会默认加上'\0'，当作字符串的结束标志。
回答完毕，求采纳。
Ⅲ c语言 字符数组 字符指针 sizeof strlen 的区别
c语言 字符数组、字符指针、sizeof strlen的区别为：数据长度不同、操作不同、所占空间不同。
一、数据长度不同
1、字符数组：字符数组需要在初始化时就定义字符数组的数据长度。
2、字符指针：字符指针的数据长度由指针指向的字符数据决定。
3、sizeof strlen：sizeof strlen自动确定sizeof strlen的数据长度。
二、操作不同
1、字符数组：字符数组里的数据内容可以进行增删改操作。
2、字符指针：字符指针只是展示指向的字符数据，字符指针里的数据内容不可以进行增删改操作。
3、sizeof strlen：sizeof strlen里的数据内容可以进行增删改操作。
三、所占空间不同
1、字符数组：字符数组的所占空间以初始化时定义的数据长度决定，不会发生改变。
2、字符指针：字符指针的所占空间较小，只存放指向字符数据的指针地址。
3、sizeof strlen：sizeof strlen的所占空间根据现有的数据长度自动发生改变。
Ⅳ 字符型指针与字符指针的区别
字符数组名与字符串指针变量名的区别2009-01-19
19:08授课内容：
一、字符串指针变量的说明和使用
字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别。
对指向字符变量的指针变量应赋予该字符变量的地址。如：
char
c,*p=&c;表示p是一个指向字符变量c的指针变量。而：
char
*s="c
language";则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。
请看下面一例。main(){
char
*ps;
ps="c
language";
printf("%s",ps);
}
运行结果为：
c
language
上例中，首先定义ps是一个字符指针变量，
然后把字符串的首
地址赋予ps(应写出整个字符串，以便编译系统把该串装入连续的一
块内存单元)，并把首地址送入ps。程序中的：
char
*ps;
ps="c
language";等效于：
char
*ps="c
language";
输出字符串中n个字符后的所有字符。
二、字符指针变量的运算
main(){
char
*ps="this
is
a
book";
int
n=10;
ps=ps+n;
printf("%s\n",ps);
}
运行结果为：
book
在程序中对ps初始化时，即把字符串首地址赋予ps，当ps=
ps
+10之后，ps指向字符“b”，因此输出为"book"。
main(){
char
st[20],*ps;
int
i;
printf("input
a
string:\n");
ps=st;
scanf("%s",ps);
for(i=0;ps[i]!='\0';i++)
if(ps[i]=='k'){
printf("there
is
a
'k'
in
the
string\n");
break;
}
if(ps[i]=='\0')
printf("there
is
no
'k'
in
the
string\n");
}
本例是在输入的字符串中查找有无‘k’字符。
三、字符串指针作为函数参数的使用。
要求把一个
字符串的内容复制到另一个字符串中，并且不能使用strcpy函数。函
数cprstr的形参为两个字符指针变量。pss指向源字符串，pds指向目标字符串。表达式：
(*pds=*pss)!=`\0'
cpystr(char
*pss,char
*pds){
while((*pds=*pss)!='\0'){
pds++;
pss++;
}
}
main(){
char
*pa="china",b[10],*pb;
pb=b;
cpystr(pa,pb);
printf("string
a=%s\nstring
b=%s\n",pa,pb);
}
在上例中，程序完成了两项工作：一是把pss指向的源字符复制
到pds所指向的目标字符中，二是判断所复制的字符是否为`\0'，若
是则表明源字符串结束，不再循环。否则，pds和pss都加1，指向下
一字符。
四、使用字符串指针变量与字符数组的区别
用字符数组和字符指针变量都可实现字符串的存储和运算。
但两者是有区别的。在使用时应注意以下几个问题：
1.
字符串指针变量本身是一个变量，用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘\0’作为串的结束。字符数组是由于若干个数组元素组成的，它可用来存放整个字符串。
2.
对字符数组作初始化赋值，必须采用外部类型或静态类型，如：
static
char
st[]={“c
language”};而对字符串指针变量则无此限制，如：
char
*ps="c
language";
3.
对字符串指针方式
char
*ps="c
language";可以写为：
char
*ps;
ps="c
language";
而对数组方式：
static
char
st[]={"c
language"};不能写为：
char
st[20];
st={"c
language"};而只能对字符数组的各元素逐个赋值。
从以上几点可以看出字符串指针变量与字符数组在使用时的区别，同时也可看出使用指针变量更加方便。
前面说过，当一个指针变量在未取得确定地址前使用是危险的，容易引起错误。但是对指针变量直接赋值是可以的。因为c系统对指针变量赋值时要给以确定的地址。因此，
char
*ps="c
langage";或者
char
*ps;
ps="c
language";都是合法的。
Ⅳ 字符指针变量和字符数组的区别
简单说一下：
字符(非字符串数组，字符数组和字符串数组是有区别的，字符串数组每个元素都是一个字符串）数组是用来存放字符的数组，在内存中占一段连续的单元。所占内存存放的是字符串。定义方法为：char a[N];N为常量表达式，可初始化。字符指针是指向字符的指针，所占内存单元存放的是所指字符的内存单元。定义方法为：char *p;
完整的解答：
1）字符数组由若干个元素组成，每个元素中放一个字符，而字符指针变量中存放的地址（字符串第一个字符的地址），决不是将字符串放到字符指针变量中
2）赋值方式
对于字符数组只能对各个元素赋值，不能用以下办法对字符数组赋值：
char str[14];
str = "I love you!";
而对于字符指针变量，可采用如下赋值：
char *a;
a = "I love you!";
赋值给a的是字符串第一个元素的地址
3）对字符指针赋初值
char *a = "I love you!";
等价于
char *a;
a = "I love you!";
而对数组的初始化：
char str[14] = {"I love you!"};
不等价于
char str[14];
str = "I love you!";
4）如果定义了一个字符数组，在编译时为它分配内存单元，它有确定的地址。而定义一个字符指针变量时，给指针变量分配内存单元，在其中可以放一个字符变量的地址
char *a, str[10];
a = str;
scanf("%s", a);
先使a有确定值，即使a指向一个数组的首元素，然后输入一个字符串，把它存放在以该地址开始的若干单元中
5）指针变量的值是可以改变的，而数组名是常量
6）用指针变量指向一个格式字符串，可以用它代替printf函数的格式字符串
char * format;
fomat = "a = %d, b = %f\n"
printf(format, a, b);
相当于
printf("a = %d, b = %f\n", a, b);
因此只要改变printf所指向的字符串，就可以改变输入输出格式，这种printf函数称为可变格式输出函数
也可以用字符数组实现：
char format[];
format = "a = %d, b = %f\n"
Ⅵ C语言中指向字符串的指针和字符串的区别
抛开概念的区别，实践的方便来说，当声明指针时直接赋值了一个字符串常量，则指针不可递增减。反之可以。
Ⅶ 字符指针，字符串和字符数组的区别
字符指针变量和字符数组的区别：
简单说一下：
字符串数组是用来存放字符串的数组，在内存中占一段连续的单元。所占内存存放的是字符串。定义方法为：char a[N];N为常量表达式，可初始化。字符指针是指向字符的指针，所占内存单元存放的是所指字符的内存单元。定义方法为：char *p;
完整的解答：
1）字符数组由若干个元素组成，每个元素中放一个字符，而字符指针变量中存放的地址（字符串第一个字符的地址），决不是将字符串放到字符指针变量中
2）赋值方式
对于字符数组只能对各个元素赋值，不能用以下办法对字符数组赋值：
char str[14];
str = "I love you!";
而对于字符指针变量，可采用如下赋值：
char *a;
a = "I love you!";
赋值给a的是字符串第一个元素的地址
3）对字符指针赋初值
char *a = "I love you!";
等价于
char *a;
a = "I love you!";
而对数组的初始化：
char str[14] = {"I love you!"};
不等价于
char str[14];
str = "I love you!";
4）如果定义了一个字符数组，在编译时为它分配内存单元，它有确定的地址。而定义一个字符指针变量时，给指针变量分配内存单元，在其中可以放一个字符变量的地址
char *a, str[10];
a = str;
scanf("%s", a);
先使a有确定值，即使a指向一个数组的首元素，然后输入一个字符串，把它存放在以该地址开始的若干单元中
5）指针变量的值是可以改变的，而数组名是常量
6）用指针变量指向一个格式字符串，可以用它代替printf函数的格式字符串
char * format;
fomat = "a = %d, b = %f\n"
printf(format, a, b);
相当于
printf("a = %d, b = %f\n", a, b);
因此只要改变printf所指向的字符串，就可以改变输入输出格式，这种printf函数称为可变格式输出函数
也可以用字符数组实现：
char format[];
format = "a = %d, b = %f\n"
可以看出，用指针变量指向字符串更简洁
Ⅷ 数组和指针的区别，字符数组和字符串指针区
1.字符指针可以指向一个字符串。
我们可以用字符串常量对字符指针进行初始化。例如，有说明语句：
char *str = "This is a string.";
是对字符指针进行初始化。此时，字符指针指向的是一个字符串常量的首地址，即指向字符串的首地址。
这里要注意字符指针与字符数组之间的区别。例如，有说明语句：
char string[ ]="This is a string.";
此时，string是字符数组，它存放了一个字符串。
字符指针str与字符数组string的区别是：str是一个变量，可以改变str使它指向不同的字符串，但不能改变str所指的字符串常量。string是一个数组，可以改变数组中保存的内容。
2.实例：
char *str, *str1="This is another string.";
char string[100]="This is a string.";
则在程序中，可以使用如下语句：
str++; /* 指针str加1 */
str = "This is a NEW string."; /* 使指针指向新的字符串常量 */
str = str1; /* 改变指针str的指向 */
strcpy( string, "This is a NEW string.") /* 改变字符串的的内容 */
strcat( string, str) /* 进行串连接操作 */
在程序中，不能进行如下操作：
string++; /* 不能对数组名进行++运算 */
string = "This is a NEW string."; /* 错误的串操作 */
string = str1; /* 对数组名不能进行赋值 */
strcat(str, "This is a NEW string.") /* 不能在str的后面进行串连接 */
strcpy(str, string) /* 不能向str进行串复制 */
3．其它说明：
1) 以字符串形式出现的，编译器都会为该字符串自动添加一个0作为结束符，如在代码中写："abc",那么编译器帮你存储的是"abc\0"
2) "abc"是常量吗？答案是有时是，有时不是。
不是常量的情况："abc"作为字符数组初始值的时候就不是，如
char str[] = "abc";
因为定义的是一个字符数组，所以就相当于定义了一些空间来存放"abc"，而又因为字符数组就是把字符一个一个地存放的，所以编译器把这个语句解析为 char str[3] = {'a','b','c'};又根据上面的总结1，所以char
str[] = "abc";的最终结果是 char str[4] = {'a','b','c','\0'};
做一下扩展，如果char str[] = "abc";是在函数内部写的话，那么这里的"abc\0"因为不是常量，所以应该被放在栈上。
是常量的情况： 把"abc"赋给一个字符指针变量时，如
char* ptr = "abc";
因为定义的是一个普通指针，并没有定义空间来存放"abc"，所以编译器得帮我们找地方来放"abc"，显然，把这里的"abc"当成常量并把它放到程序的常量区是编译器最合适的选择。所以尽管ptr的类型不是const
char*，并且ptr[0] = 'x';也能编译通过，但是执行ptr[0] = 'x';就会发生运行时异常，因为这个语句试图去修改程序常量区中的东西。
记得哪本书中曾经说过char* ptr = "abc";这种写法原来在c++标准中是不允许的，但是因为这种写法在c中实在是太多了，为了兼容c，不允许也得允许。虽然允许，
但是建议的写法应该是const char* ptr = "abc";这样如果后面写ptr[0] = 'x'的话编译器就不会让它编译通过，也就避免了上面说的运行时异常。
又扩展一下，如果char* ptr = "abc";写在函数体内，那么虽然这里的"abc\0"被
放在常量区中，但是ptr本身只是一个普通的指针变量，所以ptr是被放在栈上的, 只不过是它所指向的东西被放在常量区罢了。
3) 数组的类型是由该数组所存放的东西的类型以及数组本身的大小决定的。如char s1[3]和char s2[4]，s1的类型就是char[3]，s2的类型就是char[4]，
也就是说尽管s1和s2都是字符数组，但两者的类型却是不同的。
4) 字符串常量的类型可以理解为相应字符常量数组的类型，
如"abcdef"的类型就可以看成是const char[7]
5) sizeof是用来求类型的字节数的。如int a;那么无论sizeof(int)或者是sizeof(a)都是等于4，因为sizeof(a)其实就是sizeof(type
of a)
6) 对于函数参数列表中的以数组类型书写的形式参数，编译器把其解释为普通的指针类型，如对于void func(char sa[100],int ia[20],char *p)
则sa的类型为char*，ia的类型为int*，p的类型为char*
7) 根据上面的总结，来实战一下：
对于char str[] = "abcdef";就有sizeof(str) == 7,因为str的类型是char[7]，
也有sizeof("abcdef") == 7，因为"abcdef"的类型是const
char[7]。
对于char *ptr = "abcdef";就有sizeof(ptr) == 4，因为ptr的类型是char*。
对于char str2[10] = "abcdef";就有sizeof(str2) == 10，因为str2的类型是char[10]。
对于void func(char sa[100],int ia[20],char *p);
就有sizeof(sa) == sizeof(ia) == sizeof(p) == 4，
因为sa的类型是char*，ia的类型是int*，p的类型是char*。
4.区别：
(1)字符数组由若干个元素组成，每个元素中存放字符串的一个字符，而字符指针变量中存放的是字符串的首地址。
(2)初始化方式不同。对字符数组初始化要用static存储类别，在编译时进行。而对字符指针变量初始化不必加static，在实际执行时进行。
(3)赋值方式不同。对字符数组不能整体赋值，只能转化成份量，对单个元素进行。而字符指针变量赋值可整体进行。
例如：
char s[10]；
s= \"C++\"；/*错，s是常量，怎能被赋值*/
(4)在定义一个字符数组时，编译时即已分配内存单元，有确定的地址。而定义一个字符指针变量时，给指针变量分配内存单元，但该指针变量具体指向哪个字符串，并不知道，即指针变量存放的地址不确定。例如：
char a[10];
char *p;
scanf(\"%s\"，s);/*正确*/
scanf(\"%s\"，p)；/*非常危险，p的值动态*/
(5)字符指针变量的值可以改变，字符数组名是一个常量，不能改变。例如，有简单程序：
#include <stdio.h>
int main()
{
char *s = "china man";
s+= 6;
printf("%s\n",s);
getchar();
return 0;
}
运行结果：man
Ⅸ 字符型指针和常量指针的区别
char ch='X'； //变量ch保存立即数'X'的值。
char* a=&ch; //这个是字符指针，a是指针变量，占用四字节内存（32位情况），保存ch变量内存所在的首地址。
char* const a=&ch;//这个是常指针，保证指针变量的值不变，改变了编译器不允许通过。
const char* a=&ch;//char const *a=&ch;//这两个都是指向常量的指针，常见使用的方法是前面一个，但被建议，容易理解的是后一个，它主要保证不要试图使用*a改变变量的值。
Ⅹ 字符数组与字符指针变量的区别
字符数组名与字符串指针变量名的区别2009-01-19 19:08授课内容：
一、字符串指针变量的说明和使用
字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别。
对指向字符变量的指针变量应赋予该字符变量的地址。如： char c,*p=&c;表示p是一个指向字符变量c的指针变量。而： char *s="C Language";则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。
请看下面一例。main(){
char *ps;
ps="C Language";
printf("%s",ps);
}
运行结果为：
C Language
上例中，首先定义ps是一个字符指针变量， 然后把字符串的首
地址赋予ps(应写出整个字符串，以便编译系统把该串装入连续的一
块内存单元)，并把首地址送入ps。程序中的： char *ps;
ps="C Language";等效于： char *ps="C Language";
输出字符串中n个字符后的所有字符。
二、字符指针变量的运算
main(){
char *ps="this is a book";
int n=10;
ps=ps+n;
printf("%s\n",ps);
}
运行结果为：
book
在程序中对ps初始化时，即把字符串首地址赋予ps，当ps= ps
+10之后，ps指向字符“b”，因此输出为"book"。
main(){
char st[20],*ps;
int i;
printf("input a string:\n");
ps=st;
scanf("%s",ps);
for(i=0;ps[i]!='\0';i++)
if(ps[i]=='k'){
printf("there is a 'k' in the string\n");
break;
}
if(ps[i]=='\0') printf("There is no 'k' in the string\n");
}
本例是在输入的字符串中查找有无‘k’字符。
三、字符串指针作为函数参数的使用。
要求把一个 字符串的内容复制到另一个字符串中，并且不能使用strcpy函数。函
数cprstr的形参为两个字符指针变量。pss指向源字符串，pds指向目标字符串。表达式： (*pds=*pss)!=`\0'
cpystr(char *pss,char *pds){
while((*pds=*pss)!='\0'){
pds++;
pss++; }
}
main(){
char *pa="CHINA",b[10],*pb;
pb=b;
cpystr(pa,pb);
printf("string a=%s\nstring b=%s\n",pa,pb);
}
在上例中，程序完成了两项工作：一是把pss指向的源字符复制
到pds所指向的目标字符中，二是判断所复制的字符是否为`\0'，若
是则表明源字符串结束，不再循环。否则，pds和pss都加1，指向下
一字符。
四、使用字符串指针变量与字符数组的区别
用字符数组和字符指针变量都可实现字符串的存储和运算。 但两者是有区别的。在使用时应注意以下几个问题：
1. 字符串指针变量本身是一个变量，用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘\0’作为串的结束。字符数组是由于若干个数组元素组成的，它可用来存放整个字符串。
2. 对字符数组作初始化赋值，必须采用外部类型或静态类型，如： static char st[]={“C Language”};而对字符串指针变量则无此限制，如： char *ps="C Language";
3. 对字符串指针方式 char *ps="C Language";可以写为： char *ps;
ps="C Language"; 而对数组方式： static char st[]={"C Language"};不能写为： char st[20]; st={"C Language"};而只能对字符数组的各元素逐个赋值。
从以上几点可以看出字符串指针变量与字符数组在使用时的区别，同时也可看出使用指针变量更加方便。
前面说过，当一个指针变量在未取得确定地址前使用是危险的，容易引起错误。但是对指针变量直接赋值是可以的。因为C系统对指针变量赋值时要给以确定的地址。因此， char *ps="C Langage";或者 char *ps; ps="C Language";都是合法的。