字元和指針編譯的區別

Ⅰ 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";都是合法的。