本文目錄一覽：
c語言位運算符的用法
c語言位運算符的用法1
c語言位運算符的用法如下：
一、位運算符C語言提供了六種位運算符：
按位與
| 按位或
^ 按位異或
~ 取反
左移
右移
1. 按位與運算
按位與運算符””是雙目運算符。其功能是參與運算的兩數各對應的二進位相與。只有對應的兩個二進位均為1時，結果位才為1 ，否則為0。參與運算的數以補碼方式出現。
例如：95可寫算式如下： 00001001 (9的二進制補碼)00000101 (5的二進制補碼) 00000001 (1的二進制補碼)可見95=1。
按位與運算通常用來對某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a255 運算 ( 255 的二進制數為0000000011111111)。
main(){
int a=9,b=5,c;
c=ab;
printf(“a=%d/nb=%d/nc=%d/n”,a,b,c);
}
2. 按位或運算
按位或運算符“|”是雙目運算符。其功能是參與運算的兩數各對應的二進位相或。只要對應的二個二進位有一個為1時，結果位就為1。參與運算的兩個數均以補碼出現。
例如：9|5可寫算式如下： 00001001|00000101
00001101 (十進制為13)可見9|5=13
main(){
int a=9,b=5,c;
c=a|b;
printf(“a=%d/nb=%d/nc=%d/n”,a,b,c);
}
3. 按位異或運算
按位異或運算符“^”是雙目運算符。其功能是參與運算的兩數各對應的二進位相異或，當兩對應的二進位相異時，結果為1。參與運算數仍以補碼出現，例如9^5可寫成算式如下： 00001001^00000101 00001100 (十進制為12)。
main(){
int a=9;
a=a^15;
printf(“a=%d/n”,a);
}
4. 求反運算
求反運算符～為單目運算符，具有右結合性。 其功能是對參與運算的數的各二進位按位求反。例如～9的運算為： ~(0000000000001001)結果為：1111111111110110。
5. 左移運算
左移運算符“”是雙目運算符。其功能把“ ”左邊的運算數的各二進位全部左移若干位，由“”右邊的數指定移動的位數，高位丟棄，低位補0。例如： a4 指把a的各二進位向左移動4位。如a=00000011(十進制3)，左移4位後為00110000(十進制48)。
6. 右移運算
右移運算符“”是雙目運算符。其功能是把“ ”左邊的運算數的`各二進位全部右移若干位，“”右邊的數指定移動的位數。
例如：設 a=15，a2 表示把000001111右移為00000011(十進制3)。 應該說明的是，對於有符號數，在右移時，符號位將隨同移動。當為正數時， 最高位補0，而為負數時，符號位為1，最高位是補0或是補1 取決於編譯系統的規定。Turbo C和很多系統規定為補1。
main(){
unsigned a,b;
printf(“input a number: “);
scanf(“%d”,a);
b=a5;
b=b15;
printf(“a=%d/tb=%d/n”,a,b);
}
請再看一例!
main(){
char a=’a’,b=’b’;
int p,c,d;
p=a;
p=(p8)|b;
d=p0xff;
c=(p0xff00)8;
printf(“a=%d/nb=%d/nc=%d/nd=%d/n”,a,b,c,d);
}
c語言位運算符的用法2
C語言位運算。所謂位運算，就是對一個比特(Bit)位進行操作。比特(Bit)是一個電子元器件，8個比特構成一個字節(Byte)，它已經是粒度最小的可操作單元了。
C語言提供了六種位運算符：
按位與運算()
一個比特(Bit)位只有 0 和 1 兩個取值，只有參與運算的兩個位都為 1 時，結果才為 1，否則為 0。例如11為 1，00為 0，10也為 0，這和邏輯運算符非常類似。
C語言中不能直接使用二進制，兩邊的操作數可以是十進制、八進制、十六進制，它們在內存中最終都是以二進制形式存儲，就是對這些內存中的二進制位進行運算。其他的位運算符也是相同的道理。
例如，9 5可以轉換成如下的運算：
0000 0000 — 0000 0000 — 0000 0000 — 0000 1001 (9 在內存中的存儲)
0000 0000 — 0000 0000 — 0000 0000 — 0000 0101 (5 在內存中的存儲)
———————————————————————————–
0000 0000 — 0000 0000 — 0000 0000 — 0000 0001 (1 在內存中的存儲)
也就是說，按位與運算會對參與運算的兩個數的所有二進制位進行運算，9 5的結果為 1。
又如，-9 5可以轉換成如下的運算：
1111 1111 — 1111 1111 — 1111 1111 — 1111 0111 (-9 在內存中的存儲)
0000 0000 — 0000 0000 — 0000 0000 — 0000 0101 (5 在內存中的存儲)
———————————————————————————–
0000 0000 — 0000 0000 — 0000 0000 — 0000 0101 (5 在內存中的存儲)
-9 5的結果是 5。
關於正數和負數在內存中的存儲形式，我們已在教程《整數在內存中是如何存儲的》中進行了講解。
再強調一遍，是根據內存中的二進制位進行運算的，而不是數據的二進制形式;其他位運算符也一樣。以-95為例，-9 的在內存中的存儲和 -9 的二進制形式截然不同：
1111 1111 — 1111 1111 — 1111 1111 — 1111 0111 (-9 在內存中的存儲)
-0000 0000 — 0000 0000 — 0000 0000 — 0000 1001 (-9 的二進制形式，前面多餘的 0 可以抹掉)
按位與運算通常用來對某些位清 0，或者保留某些位。例如要把 n 的高 16 位清 0 ，保留低 16 位，可以進行n 0XFFFF運算(0XFFFF 在內存中的存儲形式為 0000 0000 — 0000 0000 — 1111 1111 — 1111 1111)。
【實例】對上面的分析進行檢驗。
00001. #include
00002.
00003. int main(){
00004. int n = 0X8FA6002D;
00005. printf(“%d, %d, %X “, 9 5, -9 5, n 0XFFFF);
00006. return 0;
00007. }
運行結果：
1, 5, 2D
按位或運算(|)
參與|運算的兩個二進制位有一個為 1 時，結果就為 1，兩個都為 0 時結果才為 0。例如1|1為1，0|0為0，1|0為1，這和邏輯運算中的||非常類似。
例如，9 | 5可以轉換成如下的運算：
0000 0000 — 0000 0000 — 0000 0000 — 0000 1001 (9 在內存中的存儲)
| 0000 0000 — 0000 0000 — 0000 0000 — 0000 0101 (5 在內存中的存儲)
———————————————————————————–
0000 0000 — 0000 0000 — 0000 0000 — 0000 1101 (13 在內存中的存儲)
9 | 5的結果為 13。
又如，-9 | 5可以轉換成如下的運算：
1111 1111 — 1111 1111 — 1111 1111 — 1111 0111 (-9 在內存中的存儲)
| 0000 0000 — 0000 0000 — 0000 0000 — 0000 0101 (5 在內存中的存儲)
———————————————————————————–
1111 1111 — 1111 1111 — 1111 1111 — 1111 0111 (-9 在內存中的存儲)
-9 | 5的結果是 -9。
按位或運算可以用來將某些位置 1，或者保留某些位。例如要把 n 的高 16 位置 1，保留低 16 位，可以進行n | 0XFFFF0000運算(0XFFFF0000 在內存中的存儲形式為 1111 1111 — 1111 1111 — 0000 0000 — 0000 0000)。
【實例】對上面的分析進行校驗。
00001. #include
00002.
00003. int main(){
00004. int n = 0X2D;
00005. printf(“%d, %d, %X “, 9 | 5, -9 | 5, n | 0XFFFF0000);
00006. return 0;
00007. }
運行結果：
13, -9, FFFF002D
按位異或運算(^)
參與^運算兩個二進制位不同時，結果為 1，相同時結果為 0。例如0^1為1，0^0為0，1^1為0。
例如，9 ^ 5可以轉換成如下的運算：
0000 0000 — 0000 0000 — 0000 0000 — 0000 1001 (9 在內存中的存儲)
^ 0000 0000 — 0000 0000 — 0000 0000 — 0000 0101 (5 在內存中的存儲)
———————————————————————————–
0000 0000 — 0000 0000 — 0000 0000 — 0000 1100 (12 在內存中的存儲)
9 ^ 5的結果為 12。
又如，-9 ^ 5可以轉換成如下的運算：
1111 1111 — 1111 1111 — 1111 1111 — 1111 0111 (-9 在內存中的存儲)
^ 0000 0000 — 0000 0000 — 0000 0000 — 0000 0101 (5 在內存中的存儲)
———————————————————————————–
1111 1111 — 1111 1111 — 1111 1111 — 1111 0010 (-14 在內存中的存儲)
-9 ^ 5的結果是 -14。
按位異或運算可以用來將某些二進制位反轉。例如要把 n 的高 16 位反轉，保留低 16 位，可以進行n ^ 0XFFFF0000運算(0XFFFF0000 在內存中的存儲形式為 1111 1111 — 1111 1111 — 0000 0000 — 0000 0000)。
【實例】對上面的分析進行校驗。
00001. #include
00002.
00003. int main(){
00004. unsigned n = 0X0A07002D;
00005. printf(“%d, %d, %X “, 9 ^ 5, -9 ^ 5, n ^ 0XFFFF0000);
00006. return 0;
00007. }
運行結果：
12, -14, F5F8002D
取反運算(~)
取反運算符~為單目運算符，右結合性，作用是對參與運算的二進制位取反。例如~1為0，~0為1，這和邏輯運算中的!非常類似。。
例如，~9可以轉換為如下的運算：
~ 0000 0000 — 0000 0000 — 0000 0000 — 0000 1001 (9 在內存中的存儲)
———————————————————————————–
1111 1111 — 1111 1111 — 1111 1111 — 1111 0110 (-10 在內存中的存儲)
所以~9的結果為 -10。
例如，~-9可以轉換為如下的運算：
~ 1111 1111 — 1111 1111 — 1111 1111 — 1111 0111 (-9 在內存中的存儲)
———————————————————————————–
0000 0000 — 0000 0000 — 0000 0000 — 0000 1000 (9 在內存中的存儲)
所以~-9的結果為 8。
【實例】對上面的分析進行校驗。
00001. #include
00002.
00003. int main(){
00004. printf(“%d, %d “, ~9, ~-9 );
00005. return 0;
00006. }
運行結果：
-10, 8
左移運算()
左移運算符用來把操作數的各個二進制位全部左移若干位，高位丟棄，低位補0。
例如，93可以轉換為如下的運算：
0000 0000 — 0000 0000 — 0000 0000 — 0000 1001 (9 在內存中的存儲)
———————————————————————————–
0000 0000 — 0000 0000 — 0000 0000 — 0100 1000 (72 在內存中的存儲)
所以93的結果為 72。
又如，(-9)3可以轉換為如下的運算：
1111 1111 — 1111 1111 — 1111 1111 — 1111 0111 (-9 在內存中的存儲)
———————————————————————————–
1111 1111 — 1111 1111 — 1111 1111 — 1011 1000 (-72 在內存中的存儲)
所以(-9)3的結果為 -72
如果數據較小，被丟棄的高位不包含 1，那麼左移 n 位相當於乘以 2 的 n 次方。
【實例】對上面的結果進行校驗。
00001. #include
00002.
00003. int main(){
00004. printf(“%d, %d “, 93, (-9)3 );
00005. return 0;
00006. }
運行結果：
72, -72
右移運算()
右移運算符用來把操作數的各個二進制位全部右移若干位，低位丟棄，高位補 0 或 1。如果數據的最高位是 0，那麼就補 0;如果最高位是 1，那麼就補 1。
例如，93可以轉換為如下的運算：
0000 0000 — 0000 0000 — 0000 0000 — 0000 1001 (9 在內存中的存儲)
———————————————————————————–
0000 0000 — 0000 0000 — 0000 0000 — 0000 0001 (1 在內存中的存儲)
所以93的結果為 1。
又如，(-9)3可以轉換為如下的運算：
1111 1111 — 1111 1111 — 1111 1111 — 1111 0111 (-9 在內存中的存儲)
———————————————————————————–
1111 1111 — 1111 1111 — 1111 1111 — 1111 1110 (-2 在內存中的存儲)
所以(-9)3的結果為 -2
如果被丟棄的低位不包含 1，那麼右移 n 位相當於除以 2 的 n 次方(但被移除的位中經常會包含 1)。
【實例】對上面的結果進行校驗。
00001. #include
00002.
00003. int main(){
00004. printf(“%d, %d “, 93, (-9)3 );
00005. return 0;
00006. }
運行結果：
1, -2
c語言位運算符的用法3
一、位運算符
在計算機中，數據都是以二進制數形式存放的，位運算就是指對存儲單元中二進制位的運算。C語言提供6種位運算符。
二、位運算
位運算符 |~ ∧ 按優先級從高到低排列的順序是：
位運算符中求反運算“~“優先級最高，而左移和右移相同，居於第二，接下來的順序是按位與 ““、按位異或 “∧“和按位或 “|“。順序為~ ∧ | 。
例1：左移運算符“”是雙目運算符。其功能把“ ”左邊的運算數的各二進位全部左移若干位，由“”右邊的數指定移動的位數，高位丟棄，低位補0。
例如：
a4
指把a的各二進位向左移動4位。如a=00000011(十進制3)，左移4位後為00110000(十進制48)。
例2：右移運算符“”是雙目運算符。其功能是把“ ”左邊的運算數的各二進位全部右移若干位，“”右邊的數指定移動的位數。
例如：
設 a=15，
a2
表示把000001111右移為00000011(十進制3)。
應該說明的是，對於有符號數，在右移時，符號位將隨同移動。當為正數時，最高位補0，而為負數時，符號位為1，最高位是補0或是補1 取決於編譯系統的規定。
例3：設二進制數a是00101101 ，若通過異或運算a∧b 使a的高4位取反，低4位不變，則二進制數b是。
解析：異或運算常用來使特定位翻轉，只要使需翻轉的位與1進行異或操作就可以了，因為原數中值為1的位與1進行異或運算得0 ，原數中值為0的位與1進行異或運算結果得1。而與0進行異或的位將保持原值。異或運算還可用來交換兩個值，不用臨時變量。
如 int a=3 , b=4;，想將a與b的值互換，可用如下語句實現：
a=a∧b;
b=b∧a;
a=a∧b;
所以本題的答案為： 11110000 。
c語言string的用法大全
C語言是一門面向過程的、抽象化的通用程序設計語言，廣泛應用於底層開發。C語言能以簡易的方式編譯、處理低級存儲器。C 語言string的用法有哪些呢，請看看下面我為你整理 總結 的c語言string的用法大全_C語言中string使用 方法 。
c語言string的用法
函數原型:char *strdup(const char *s)
函數功能:字符串拷貝，目的空間由該函數分配
函數返回:指向拷貝後的字符串指針
參數說明:src-待拷貝的源字符串
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
#includealloc.h
intmain()
{
char*dup_str,*string=”abcde”;
dup_str=strdup(string);
printf(“%s”,dup_str);
free(dup_str);
return0;
}
@函數名稱:strcpy
函數原型:char* strcpy(char* str1,char* str2);
函數功能:把str2指向的字符串拷貝到str1中去
函數返回:返回str1,即指向str1的指針
參數說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
charstring[10];
char*str1=”abcdefghi”;
strcpy(string,str1);
printf(“thestringis:%s\n”,string);
return0;
}
@函數名稱:strncpy
函數原型:char *strncpy(char *dest, const char *src，intcount)
函數功能:將字符串src中的count個字符拷貝到字符串dest中去
函數返回:指向dest的指針
參數說明:dest-目的字符串，src-源字符串，count-拷貝的字符個數
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
char*src=”bbbbbbbbbbbbbbbbbbbb”;//20’b’s
chardest[50]=”aaaaaaaaaaaaaaaaaaaa”;//20’a’s
puts(dest);
strncpy(dest,src,10);
puts(dest);
return0;
}
輸出：
[cpp] view plain
/*******************************************
aaaaaaaaaaaaaaaaaaaa
bbbbbbbbbbaaaaaaaaaa
*******************************************/
注意：strncpy只複製指定長度的字符，不會自動在末尾加’\0’。若指定長度超過源字符串長度，不夠的部分補‘\0’，
@函數名稱:strcat
函數原型:char* strcat(char * str1,char * str2);
函數功能:把字符串str2接到str1後面,str1最後的’\0’被取消
函數返回:str1
參數說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
charbuffer[80];
strcpy(buffer,”Hello”);
strcat(buffer,”world”);
printf(“%s\n”,buffer);
return0;
}
@函數名稱:strncat
函數原型:char *strncat(char *dest, const char *src, size_t maxlen)
函數功能:將字符串src中前maxlen個字符連接到dest中
函數返回:
參數說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
charbuffer[80];
intmain()
{
strcpy(buffer,”Hello”);
strncat(buffer,”world”,8);
printf(“%s\n”,buffer);
strncat(buffer,”*************”,4);
printf(“%s\n”,buffer);
return0;
}
注意：與strncpy不同的是，strncat會自動在末尾加‘\0’，若指定長度超過源字符串長度，則只複製源字符串長度即停止
@函數名稱:strcmp
函數原型:int strcmp(char * str1,char * str2);
函數功能:比較兩個字符串str1,str2.
函數返回:str1str2,返回負數;str1=str2,返回 0;str1str2,返回正數.
參數說明:
所屬文件:string.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
char*buf1=”aaa”,*buf2=”bbb”,*buf3=”ccc”;
intptr;
ptr=strcmp(buf2,buf1);
if(ptr0)
printf(“buffer2isgreaterthanbuffer1\n”);
else
printf(“buffer2islessthanbuffer1\n”);
ptr=strcmp(buf2,buf3);
if(ptr0)
printf(“buffer2isgreaterthanbuffer3\n”);
else
printf(“buffer2islessthanbuffer3\n”);
return0;
}
@函數名稱:strncmp
函數原型:int strncmp(char *str1,char *str2,int count)
函數功能:對str1和str2中的前count個字符按字典順序比較
函數返回:小於0：str1str2，等於0：str1=str2，大於0：str1str2
參數說明:str1,str2-待比較的字符串，count-比較的長度
所屬文件:string.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
charstr1[]=”aabbc”;//
charstr2[]=”abbcd”;//
//為使測試程序更簡練，此處假定了strncmp只返回-1,0,1三個數
charres_info[]={”,’=’,”};
intres;
//前1個字符比較
res=strncmp(str1,str2,1);
printf(“1：str1%cstr2\n”,res_info[res+1]);
//前3個字符比較
res=strncmp(str1,str2,3);
printf(“3：str1%cstr2\n”,res_info[res+1]);
}
輸出：
[cpp] view plain
/****************************************
1：str1=str2
3：str1str2
*****************************************/
@函數名稱:strpbrk
函數原型:char *strpbrk(const char *s1, const char *s2)
函數功能:得到s1中第一個“同時也出現在s2中”字符的位置指針
函數返回:位置指針
參數說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
char*p=”Findallvowels”;
p=strpbrk(p+1,”aeiouAEIOU”);
while(p)
{
printf(“%s\n”,p);
p=strpbrk(p+1,”aeiouAEIOU”);
}
return0;
}
輸出：
[cpp] view plain
/**************************************
indallvowels
allvowels
owels
els
**************************************/
@函數名稱:strcspn
函數原型:int strcspn(const char *s1, const char *s2)
函數功能:統計s1中從頭開始直到第一個“來自s2中的字符”出現的長度
函數返回:長度
參數說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
printf(“%d\n”,strcspn(“abcbcadef”,”cba”));
printf(“%d\n”,strcspn(“xxxbcadef”,”cba”));
printf(“%d\n”,strcspn(“123456789″,”cba”));
return0;
}
輸出：
[cpp] view plain
/************************
3
9
************************/
@函數名稱:strspn
函數原型:int strspn(const char *s1, const char *s2)
函數功能:統計s1中從頭開始直到第一個“不來自s2中的字符”出現的長度
函數返回:位置指針
參數說明:
所屬文件:string.h
[html] view plain
#includestdio.h
#includestring.h
#includealloc.h
intmain()
{
printf(“%d\n”,strspn(“abcbcadef”,”cba”));
printf(“%d\n”,strspn(“xxxbcadef”,”cba”));
printf(“%d\n”,strspn(“123456789″,”cba”));
return0;
}
輸出：
[cpp] view plain
/************************
6
************************/
@函數名稱:strchr
函數原型:char* strchr(char* str,char ch);
函數功能:找出str指向的字符串中第一次出現字符ch的位置
函數返回:返回指向該位置的指針,如找不到,則返回空指針
參數說明:str-待搜索的字符串，ch-查找的字符
所屬文件:string.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
char*str=”Thisisastring!”;
charch;
char*p;
while(1)
{
printf(“Pleaseinputachar:”);
ch=getchar();
p=strchr(str,ch);
if(p)
printf(“%cisthe%dcharacterof\”%s\”\n”,ch,(int)(p-str+1),str);
else
printf(“Notfound!\n”);
printf(“PressESCtoquit!\n\n”);
if(27==getch())
break;
fflush(stdin);
}
return0;
}
運行結果：
[cpp] view plain
/********************************************
Pleaseinputachar:i
iisthe3characterof”Thisisastring!”
PressESCtoquit!
Pleaseinputachar:l
Notfound!
PressESCtoquit!
Pleaseinputachar:s
sisthe4characterof”Thisisastring!”
PressESCtoquit!
**********************************************/
@函數名稱:strrchr
函數原型:char *strrchr(const char *s, int c)
函數功能:得到字符串s中最後一個含有c字符的位置指針
函數返回:位置指針
參數說明:
所屬文件:string.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
charstring[15];
char*ptr,c=’r’;
strcpy(string,”Thisisastring”);
ptr=strrchr(string,c);
if(ptr)
printf(“Thecharacter%cisatposition:%d”,c,ptr-string);
else
printf(“Thecharacterwasnotfound”);
return0;
}
@函數名稱:strstr
函數原型:char* strstr(char* str1,char* str2);
函數功能:找出str2字符串在str1字符串中第一次出現的位置(不包括str2的串結束符)
函數返回:返回該位置的指針,如找不到,返回空指針
參數說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
char*str1=”OpenWatcomC/C++”,*str2=”Watcom”,*ptr;
ptr=strstr(str1,str2);
printf(“Thesubstringis:%s\n”,ptr);
return0;
}
輸出：
The substringis:Watcom C/C++
@函數名稱:strrev
函數原型:char *strrev(char *s)
函數功能:將字符串中的所有字符顛倒次序排列
函數返回:指向s的指針
參數說明:
所屬文件:string.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
charforward[]=”string”;//原文中定義為char*是不對的，指向代碼段的指針內容是不可變的
printf(“Beforestrrev():%s”,forward);
strrev(forward);
printf(“Afterstrrev():%s”,forward);
return0;
}
輸出：
[cpp] view plain
/************************************
Beforestrrev():string
Afterstrrev():gnirts
************************************/
@函數名稱:strnset
函數原型:char *strnset(char *s, int ch, size_t n)
函數功能:將字符串s中前n個字符設置為ch的值
函數返回:指向s的指針
參數說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
charstring[]=”aaaaaaaaaaaaaaaaaaaaaaa”;
charletter=’x’;
printf(“stringbeforestrnset:%s\n”,string);
strnset(string,letter,10);
printf(“stringafterstrnset:%s\n”,string);
return0;
}
輸出：
[cpp] view plain
/*************************************************
stringbeforestrnset:aaaaaaaaaaaaaaaaaaaaaaa
stringafterstrnset:xxxxxxxxxxaaaaaaaaaaaaa
*************************************************/
@函數名稱:strset
函數原型:char *strset(char *s, int ch)
函數功能:將字符串s中所有字符設置為ch的值
函數返回:指向s的指針
參數說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
charstring[10]=”123456789″;
charsymbol=’c’;
printf(“Beforestrset():%s”,string);
strset(string,symbol);
printf(“Afterstrset():%s”,string);
return0;
}
@函數名稱:strtok
函數原型:char *strtok(char *s1, const char *s2)
函數功能:分解s1字符串為用特定分隔符分隔的多個字符串(一般用於將英文句分解為單詞)
函數返回:字符串s1中首次出現s2中的字符前的子字符串指針
參數說明:s2一般設置為s1中的分隔字符
規定進行子調用時（即分割s1的第二、三及後續子串）第一參數必須是NULL
在每一次匹配成功後，將s1中分割出的子串位置替換為NULL(摘下鏈中第一個環)，因此s1被破壞了
函數會記憶指針位置以供下一次調用
所屬文件:string.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
char*p;
char*buffer;
char*delims={“.,”};
buffer=strdup(“Findwords,allofthem.”);
printf(“%s\n”,buffer);
p=strtok(buffer,delims);
while(p!=NULL){
printf(“word:%s\n”,p);
p=strtok(NULL,delims);
}
printf(“%s\n”,buffer);
return0;
}//根據測試，可以隨時給strtok的第一個參數輸入一個新的字符串，開始新字符串的分隔
PS：根據測試，可以隨時給strtok的第一個參數輸入一個新的字符串，開始新字符串的分隔
@函數名稱:strupr
函數原型:char *strupr(char *s)
函數功能:將字符串s中的字符變為大寫
函數返回:
參數說明:
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
charstring[]=”abcdefghijklmnopqrstuvwxyz”,*ptr;//會影響原字符串的內存，用char[]來聲明
ptr=strupr(string);
printf(“%s”,ptr);
return0;
}
@函數名稱:strlwr
函數原型:char *strlwr(char *s)
函數功能:將字符串中的字符變為小寫字符
函數返回:指向s的指針
參數說明:
所屬文件:string.h
[cpp] view plain
#includestring.h
intmain()
{
charstr[]=”HOWTOSAY”;
printf(“%s”,strlwr(str));
return0;
}
@函數名稱:strerror
函數原型:char *strerror(int errnum)
函數功能:得到錯誤信息的內容信息
函數返回:錯誤提示信息字符串指針
參數說明:errnum-錯誤編號
所屬文件:string.h
[cpp] view plain
#includestdio.h
#includeerrno.h
intmain()
{
char*buffer;
buffer=strerror(errno);
printf(“Error:%s”,buffer);
return0;
}
@函數名稱:memcpy
函數原型:void *memcpy(void *dest, const void *src, size_t n)
函數功能:字符串拷貝
函數返回:指向dest的指針
參數說明:src-源字符串，n-拷貝的最大長度
所屬文件:string.h,mem.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
charsrc[]=”******************************”;
chardest[]=”abcdefghijlkmnopqrstuvwxyz0123456709″;
char*ptr;
printf(“destinationbeforememcpy:%s\n”,dest);
ptr=memcpy(dest,src,strlen(src));
if(ptr)
printf(“destinationaftermemcpy:%s\n”,dest);
else
printf(“memcpyfailed”);
return0;
}
輸出：
[cpp] view plain
/*************************************************************
destinationbeforememcpy:abcdefghijlkmnopqrstuvwxyz0123456709
destinationaftermemcpy:******************************456709
**************************************************************/
@函數名稱:memccpy
函數原型:void *memccpy(void *dest, const void *src, int c, size_t n)
函數功能:字符串拷貝，到指定長度或遇到指定字符時停止拷貝
函數返回:
參數說明:src-源字符串指針，c-中止拷貝檢查字符，n-長度,dest-拷貝底目的字符串指針
所屬文件:string.h,mem.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
char*src=”Thisisthesourcestring”;
chardest[50];
char*ptr;
ptr=memccpy(dest,src,’c’,strlen(src));
if(ptr)
{
*ptr=’\0′;
printf(“Thecharacterwasfound:%s”,dest);
}
else
printf(“Thecharacterwasn’tfound”);
return0;
}
輸出：
[cpp] view plain
/*****************************************
Thecharacterwasfound:Thisisthesourc
*****************************************/
PS：指定字符被複制到dest中，memccpy返回了dest中指定字符的下一處的地址，返回NULL表示未遇到指定字符
@函數名稱:memchr
函數原型:void *memchr(const void *s, int c, size_t n)
函數功能:在字符串中第開始n個字符中尋找某個字符c的位置
函數返回:返回c的位置指針，返回NULL時表示未找到
參數說明:s-要搜索的字符串，c-要尋找的字符，n-指定長度
所屬文件:string.h,mem.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
charstr[17];
char*ptr;
strcpy(str,”Thisisastring”);
ptr=memchr(str,’r’,strlen(str));
if(ptr)
printf(“Thecharacter’r’isatposition:%d”,ptr-str);
else
printf(“Thecharacterwasnotfound”);
return0;
}
@函數名稱:memcmp
函數原型:int memcmp(const void *s1, const void *s2,size_t n)
函數功能:按字典順序比較兩個串s1和s2的前n個字節
函數返回:0,=0,0分別表示s1,=,s2
參數說明:s1,s2-要比較的字符串，n-比較的長度
所屬文件:string.h,mem.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
char*buf1=”ABCDE123″;
char*buf2=”abcde456″;
intstat;
stat=memcmp(buf1,buf2,5);
printf(“Thestringstoposition5are”);
if(stat)printf(“not”);
printf(“thesame\n”);
return0;
}
@函數名稱:memicmp
函數原型:int memicmp(const void *s1, const void *s2, size_t n)
函數功能:按字典順序、不考慮字母大小寫對字符串s1,s2前n個字符比較
函數返回:0,=0,0分別表示s1,=,s2
參數說明:s1,s2-要比較的字符串，n-比較的長度
所屬文件:string.h,mem.h
[cpp] view plain
#includestdio.h
#includestring.h
intmain()
{
char*buf1=”ABCDE123″;
char*buf2=”abcde456″;
intstat;
stat=memicmp(buf1,buf2,5);
printf(“Thestringstoposition5are”);
if(stat)printf(“not”);
printf(“thesame”);
return0;
}
輸出：
[cpp] view plain
/**************************************
Thestringstoposition5arethesame
***************************************/
@函數名稱:memmove
函數原型:void *memmove(void *dest, const void *src, size_t n)
函數功能:字符串拷貝
函數返回:指向dest的指針
參數說明:src-源字符串，n-拷貝的最大長度
所屬文件:string.h,mem.h
[cpp] view plain
#includestring.h
#includestdio.h
intmain()
{
chardest[40]=”abcdefghijklmnopqrstuvwxyz0123456789″;
printf(“destinationpriortomemmove:%s\n”,dest);
memmove(dest+1,dest,35);
printf(“destinationaftermemmove:%s”,dest);
return0;
}
PS：與memcpy不同的是，memmove可以處理目的字符串與源字符串地址空間出現重疊的情況，可保證待複製的內容不被破壞。
@函數名稱: memset
函數原型: void *memset(void *s, int c, size_t n)
函數功能: 字符串中的n個字節內容設置為c
函數返回:
參數說明: s-要設置的字符串，c-設置的內容，n-長度
所屬文件: string.h,mem.h
[cpp] view plain
#includestring.h
#includestdio.h
#includemem.h
intmain()
{
charbuffer[]=”Helloworld”;
printf(“Bufferbeforememset:%s/n”,buffer);
memset(buffer,’*’,strlen(buffer)-1);
printf(“Bufferaftermemset:%s”,buffer);
return0;
}
c語言string的用法大全相關 文章 ：
★ c語言string的用法
★ c語言的用法
★ Linux C語言字符與字符串處理
★ c語言中strcmp的用法
★ c語言大括號的用法
★ c語言位運算符的用法
★ c語言char的用法
★ c語言中sort的用法詳解
★ c語言中int的用法
★ c語言map的用法
c語言中各種語句的用途用法
auto用於說明自動變量，通常不用；volatile（易變的）表示該變量不經過賦值，其值也可能被改變（例如表示時鐘的變量、表示通信端口的變量等）。
C語言32個關鍵字
[code]auto ：聲明自動變量 一般不使用
double ：聲明雙精度變量或函數
int： 聲明整型變量或函數
struct：聲明結構體變量或函數
break：跳出當前循環
else ：條件語句否定分支（與 if 連用）
long ：聲明長整型變量或函數
switch :用於開關語句
case：開關語句分支
enum ：聲明枚舉類型
register：聲明積存器變量
typedef：用以給數據類型取別名（當然還有其他作用）
char ：聲明字符型變量或函數
extern：聲明變量是在其他文件正聲明（也可以看做是引用變量）
return ：子程序返回語句（可以帶參數，也看不帶參數）
union：聲明聯合數據類型
const ：聲明只讀變量
float：聲明浮點型變量或函數
short ：聲明短整型變量或函數
unsigned：聲明無符號類型變量或函數
continue：結束當前循環，開始下一輪循環
for：一種循環語句(可意會不可言傳）
signed：生命有符號類型變量或函數
void ：聲明函數無返回值或無參數，聲明無類型指針（基本上就這三個作用）
default：開關語句中的“其他”分支
goto：無條件跳轉語句
sizeof：計算數據類型長度
volatile：說明變量在程序執行中可被隱含地改變
do ：循環語句的循環體
while ：循環語句的循環條件
static ：聲明靜態變量
if:條件語句 [/code]
C語言各類符號意義以及用法？
auto ：聲明自動變量
short ：聲明短整型變量或函數
int： 聲明整型變量或函數
long ：聲明長整型變量或函數
float：聲明浮點型變量或函數
double ：聲明雙精度變量或函數
char ：聲明字符型變量或函數
struct：聲明結構體變量或函數
union：聲明共用數據類型
enum ：聲明枚舉類型
typedef：用以給數據類型取別名
const ：聲明只讀變量
unsigned：聲明無符號類型變量或函數
signed：聲明有符號類型變量或函數
extern：聲明變量是在其他文件中聲明
register：聲明寄存器變量
static ：聲明靜態變量
volatile：說明變量在程序執行中可被隱含地改變
void ：聲明函數無返回值或無參數，聲明無類型指針
if:條件語句 else ：條件語句否定分支（與 if 連用）
switch :用於開關語句 case：開關語句分支
for：一種循環語句
do ：循環語句的循環體 while ：循環語句的循環條件
goto：無條件跳轉語句
continue：結束當前循環，開始下一輪循環
break：跳出當前循環
default：開關語句中的“其他”分支
sizeof：計算數據類型長度
return ：子程序返回語句（可以帶參數，也可不帶參數）循環條件
原創文章，作者：UHDD，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/140882.html
微信掃一掃 
支付寶掃一掃 