c语言位操作总结

c语言位操作总结（精选5篇）

篇1：c语言位操作总结

老分不清一个&号和俩的用法，今天专门拿出来整理整理：

一、逻辑运算符：

包括：1。&&逻辑与 2。||逻辑或 3。!逻辑非

逻辑运算符用于对包含关系运算符的表达式进行合并或取非 对于使用逻辑运算符的表达式，返回0表示“假”，返回1表示“真”。关于逻辑运算符的解释 请注意：任何使用两个字符做符号的运算符，两字符之间不应有空格，即将==写成= =是错误的。假设一个程序在同时满足条件a<10和b==7时，必须执行某些操作。应使用关系运算符和逻辑运算符“与”来写这个

条件的代码。用&&表示“与”运算符，该条件代码如下：

(a<10)&&(b==7);类似地，“或”是用于检查两个条件中是否有一个为真的运算符。它由两个连续的管道符号(||)表示。如果上例

改为：如果任一语句为真，则程序需执行某些操作，则条件代码如下：

(a<10)||(b==7);第三个逻辑运算符“非”用一个感叹号(!)表示。这个运算符对表达式的真值取反。例如，如果变量s小于10，程序

程序需执行某些操作，则条件代码如下：

(s<10)或

(!(s>=10))//s不大于等于10 关系运算符和逻辑运算符的优先级一般都低于算术运算符。例如，5>4+3的计算与5>(4+3)运算符是一样的，即

先计算4+3，再执行关系运算。此表达示的结果为“假”，即，将返回0。下面的语句

printf(“%d”,5>4+3);将输出 0

可以总结为：&&的结果是真真为真。||的结果是假假为假。

二、位运算符：

包括：1。&位与符 2。|位或符 3。^位异或符 4。~位取反符

以操作数12为例。位运算符将数字12视为1100。位运算符将操作数视为位而不是数值。数值 可以是任意进制的：十进制、八进制或十六进制。位运算符则将操作数转化为二进制，并相应地返回1或0。

位运算符将数字视为二进制值，并按位进行相应运算，运算完成后再重新转换为数字。例如： 表达式10&15表示(1010 & 1111)，它将返回表示1010的值10。因为真真得真，或者是11得1，同位全是1结果也是1 表达式10|15表示(1010 | 1111),它将返回表示1111的值15。假假得假。全零得零。

表达式10^15表示(1010 ^ 1111), 它将返回表示0101的值5。此时是同性相斥，相同的就为假。表达式~10表示(~1010)，它将返回表示0101的值-11。此号好理解，按位取反

C语言运算符 百科名片

运算符是告诉编译程序执行特定算术或逻辑操作的符号。C语言的运算范围很宽，把除了控制语句和输入输出以外的几乎所有的基本操作都作为运算符处理。主要分为三大类：算术运算符、关系运算符与逻辑运算符、按位运算符。除此之外，还有一些用于完成特殊任务的运算符。

目录

C语言运算符分类

运算符优先级与结合性

运算符优先级等级口诀及注释运算符优先级等级口诀 运算符优先级等级注释

运算符应用举例C语言运算符分类 运算符优先级与结合性

运算符优先级等级口诀及注释运算符优先级等级口诀 运算符优先级等级注释 运算符应用举例

展开编辑本段C语言运算符分类

1级（左结合）

()圆括号；[]下标运算符；->指向结构体成员运算符；.结构体成员运算符。

2级（右结合）

!逻辑非运算符；~按位取反运算符；++前缀增量运算符；--前缀减量运算符；+正号运算符；-负号运算符；(类型)类型转换运算符；*指针运算符；&地址运算符；sizeof长度运算符。

3级（左结合）

*乘法运算符；/除法运算符；%取余运算符。

4级（左结合）

+加法运算符；-减法运算符。

5级（左结合）

<<左移运算符；>>右移运算符。

6级（左结合）

<、<=、>、>=关系运算符。

7级（左结合）

==等于运算符；!=不等于运算符。

8级（左结合）

&按位与运算符。

9级（左结合）

^按位异或运算符。

10级（左结合）

|按位或运算符。

11级（左结合）

&&逻辑与运算符。

12级（左结合）

||逻辑或运算符。

13级（右结合）

? :条件运算符。

14级（右结合）

=、+=、-=、*=、/=、%=、&=、^=、|=、<<=、>>=赋值运算符。

15级（左结合）,逗号运算符。编辑本段运算符优先级与结合性

运算符的优先级：C语言中，运算符的运算优先级共分为15 级。1 级最高，15 级最低。在表达式中，优先级较高的先于优先级较低的进行运算。而在一个运算量两侧的运算符优先级相同时，则按运算符的结合性所规定的结合方向处理。

运算符的结合性：C语言中各运算符的结合性分为两种，即左结合性(自左至右)和右结合性(自右至左)。例如算术运算符的结合性是自左至右，即先左后右。如有表达式x-y+z则y 应先与“-”号结合，执行x-y 运算，然后再执行+z 的运算。这种自左至右的结合方向就称为“左结合性”。而自右至左的结合方向称为“右结合性”。最典型的右结合性运算符是赋值运算符。如x=y=z,由于“=”的右结合性，应先执行y=z 再执行x=(y=z)

运算。C语言运算符中有不少为右结合性，应注意区别，以避免理解错误。

优先级从上到下依次递减，最上面具有最高的优先级，逗号操作符具有最低的优先级。

所有的优先级中，只有三个优先级是从右至左结合的，它们是单目运算符、条件运算符、赋值运算符。其它的都是从左至右结合。

具有最高优先级的其实并不算是真正的运算符，它们算是一类特殊的操作。()是与函数相关，[]与数组相关，而－>及.是取结构成员。

其次是单目运算符，所有的单目运算符具有相同的优先级，因此在我认为的真正的运算符中它们具有最高的优先级，又由于它们都是从右至左结合的，因此*p++与*(p++)等效是毫无疑问的。

另外在C语言里，没有前置后置之分，因为++--是右结合所以右侧优先运算，表现为 “操作数后置优先级比较高” 的假象，前置和后置的区分是因为运算符重载而后加入C++的接下来是算术运算符，*、/、%的优先级当然比+、－高了。

移位运算符紧随其后。

其次的关系运算符中，<<= >>=要比 ==!=高一个级别，不大好理解。

所有的逻辑操作符都具有不同的优先级（单目运算符除外，！和~）

逻辑位操作符的“与”比“或”高，而“异或”则在它们之间。

跟在其后的&&比||高。

接下来的是条件运算符，赋值运算符及逗号运算符。

在C语言中，只有4个运算符规定了运算方向，它们是&&、| |、条件运算符及赋值运算符。

&&、| |都是先计算左边表达式的值，当左边表达式的值能确定整个表达式的值时，就不再计算右边表达式的值。如 a = 0 && b;&&运算符的左边位0，则右边表达式b就不再判断。

在条件运算符中。如a?b:c；先判断a的值，再根据a的值对b或c之中的一个进行求值。

赋值表达式则规定先对右边的表达式求值，因此使 a = b = c = 6;成为可能。编辑本段运算符优先级等级口诀及注释 运算符优先级等级口诀

圆方括号、箭头一句号，自增自减非反负、针强地址长度，乘除，加减，再移位，小等大等、等等不等，八位与，七位异，六位或，五与，四或，三疑，二赋，一真逗。

其中“，”号为一个等级分段。运算符优先级等级注释

“圆方括号、箭头一句号”指的是第15级的运算符。其中圆方括号很明显“（）、[]”，箭头指的是指向结构体成员运算符“->”，句号指的是结构体成员运算符“.”；

“自增自减非反负、针强地址长度”指的是第14级的运算符。其中非指的是逻辑运算符“!”，反指的是按位取反运算符“~”，负指的是负号运算符“－”，针指的是指针运算符“*”，强指的是强制类型转换运算符，地址指的是地址运算符“&”，长度指的是长度运算符“sizeof”；

“乘除，加减，再移位”移位指的是左移运算符“<<”和右移运算符“>>”，其中除法还包括了取余运算符“%”；

“小等大等、等等不等”指的是第10级到第9级的运算符：<、<=、>和>=，等等指的是等于运算符==，不等指的是不等于运算符!=

“八位与，七位异，六位或”其中八位与指的是第8级的按位与运算符“&”，七位异指的是第7级的按位异或运算符“^”，六位或指的是第6级的按位或运算符“||”；

“五与，四或”指的是第5级、第4级的逻辑与运算符“&&”和逻辑或运算符“||”；

“三疑，二赋，一真逗”指的是第3级到第1级的运算符。其中，三疑指的是条件运算符“？：”（三有双重含义：即指优先级别是三，它的运算符类型也是三目，疑也取“?”之意），二赋指的是赋值运算符=、+=、-=、*=、/=、%=、>>=、<<=、&=、^=和|=，一真逗指的是第1级的“，”运算符，真字只是为了语句需要罢了。

由于C语言的运算符优先级与C++的不完全一样(主要是增加了几个运算符)，所以这个口诀不能完全实用于C++.但是应该能够兼容，大家可以比较一下他们的区别应该就能够很快掌握C++的优先级的！编辑本段运算符应用举例

·赋值运算符：a=5;a=b=0;

第一个赋值语句把5赋给变量a；第二个赋值语句的意思是把0同时赋值给两个变量。这是因为赋值语句是从右向左运算的，也就是说从右端开始计算，先b=0，然后a=b。

·复合赋值运算符：a=1;a+=3;

上面第二个赋值语句等价于a=a+3;即a=4。

·算术运算符：Area=Height*Width;num=num1+num2/num3-num4;

第一个赋值语句Height和Width相乘结果赋给变量Area；第二个赋值语句先完成num2与num3的整除运算，然后与num1相加，再减去num4，结果赋给num。运算符运算顺序先算乘除再算加减。单目正和单目负最先运算。

·逻辑运算符：a=1,b=1;a||b-1;

因为a=1为真值，所以不管b-1是不是真值，总的表达式一定为真值，这时后面的表达式就不会再计算了。

·关系运算符：if(a>0)...如果a>0，则执行if语句中的内容，否则退出。

·条件运算符：a=(b>0)?b:-b;

当b>0时，a=b；当b不大于0时，a=-b；其实上面的意思就是把b的绝对值赋值给a。

·逗号运算符：b=2,c=7,d=5;a=(++b,c--,d+3);

有三个表达式，用逗号分开，所以最终的值应该是最后一个表达式的值，也就是d+3=8，所以a=8。

篇2：c语言位操作总结

strcpy(p, p1)复制字符串

strncpy(p, p1, n)复制指定长度字符串

strcat(p, p1)附加字符串

strncat(p, p1, n)附加指定长度字符串

strlen(p)取字符串长度

strcmp(p, p1)比较字符串

strcasecmp忽略大小写比较字符串 strncmp(p, p1, n)比较指定长度字符串

strchr(p, c)在字符串中查找指定字符

strrchr(p, c)在字符串中反向查找

strstr(p, p1)查找字符串

strpbrk(p, p1)以目标字符串的所有字符作为集合，在当前字符串查找该集合的任一元素

strspn(p, p1)以目标字符串的所有字符作为集合，在当前字符串查找不属于该集合的任一元素的偏移

strcspn(p, p1)以目标字符串的所有字符作为集合，在当前字符串查找属于该集合的任一元素的偏移

* 具有指定长度的字符串处理函数在已处理的字符串之后填补零结尾符

2）字符串到数值类型的转换

strtod(p, ppend)从字符串 p 中转换 double 类型数值，并将后续的字符串指针存储到 ppend 指向的 char* 类型存储。strtol(p, ppend, base)从字符串 p 中转换 long 类型整型数值，base 显式设置转换的整型进制，设置为 0 以根据特定格式判断所用进制，0x, 0X 前缀以解释为十六进制格式整型，0

前缀以解释为八进制格式整型 atoi(p)字符串转换到 int 整型

atof(p)字符串转换到 double 符点数

atol(p)字符串转换到 long 整型

3）字符检查

isalpha()检查是否为字母字符

isupper()检查是否为大写字母字符

islower()检查是否为小写字母字符

isdigit()检查是否为数字

isxdigit()检查是否为十六进制数字表示的有效字符

isspace()检查是否为空格类型字符

iscntrl()检查是否为控制字符

ispunct()检查是否为标点符号

isalnum()检查是否为字母和数字

isprint()检查是否是可打印字符

isgraph()检查是否是图形字符，等效于 isalnum()| ispunct()

4）函数原型

原型：strcpy(char destination[], const char source[]);功能：将字符串source拷贝到字符串destination中

例程：

#include #include void main(void){

char str1[10] = { “TsinghuaOK”};

char str2[10] = { “Computer”};

cout <

运行结果是:Computer

第二个字符串将覆盖掉第一个字符串的所有内容！

注意：在定义数组时，字符数组1的字符串长度必须大于或等于字符串2的字符串长度。不能用赋值语句将一个字符串常量或字符数组直接赋给一个字符数组。所有字符串处理函数都包含在头文件string.h中。

strncpy(char destination[], const char source[], int numchars);

strncpy：将字符串source中前numchars个字符拷贝到字符串destination中。

strncpy函数应用举例

原型：strncpy(char destination[], const char source[], int numchars);功能：将字符串source中前numchars个字符拷贝到字符串destination中

例程：

#include #include void main(void){

char str1[10] = { “Tsinghua ”};

char str2[10] = { “Computer”};

cout <

运行结果：Comnghua

注意：字符串source中前numchars个字符将覆盖掉字符串destination中前numchars个字符！

原型：strcat(char target[], const char source[]);功能：将字符串source接到字符串target的后面

例程：

#include #include void main(void){

char str1[] = { “Tsinghua ”};

char str2[] = { “Computer”};

cout <

运行结果：Tsinghua Computer

注意：在定义字符数组1的长度时应该考虑字符数组2的长度，因为连接后新字符串的长度为两个字符串长度之和。进行字符串连接后，字符串1的结尾符将自动被去掉，在结尾串末尾保留新字符串后面一个结尾符。

原型：strncat(char target[], const char source[], int numchars);功能：将字符串source的前numchars个字符接到字符串target的后面

例程：

#include #include void main(void){

char str1[] = { “Tsinghua ”};

char str2[] = { “Computer”};

cout <

运行结果：Tsinghua Com

原型：int strcmp(const char firststring[], const char secondstring);功能：比较两个字符串firststring和secondstring 例程：

#include #include void main(void){

char buf1[] = “aaa”;

char buf2[] = “bbb”;

char buf3[] = “ccc”;

int ptr;

ptr = strcmp(buf2,buf1);

if(ptr > 0)

cout <<“Buffer 2 is greater than buffer 1”<

else

cout <<“Buffer 2 is less than buffer 1”<

ptr = strcmp(buf2,buf3);

if(ptr > 0)

cout <<“Buffer 2 is greater than buffer 3”<

else

cout <<“Buffer 2 is less than buffer 3”<

运行结果是:Buffer 2 is less than buffer 1

Buffer 2 is greater than buffer 3

原型：strlen(const char string[]);功能：统计字符串string中字符的个数

例程：

#include #include void main(void){

char str[100];

cout <<“请输入一个字符串:”;

cin >>str;

cout <<“The length of the string is :”<

运行结果The length of the string is x(x为你输入的字符总数字)

注意：strlen函数的功能是计算字符串的实际长度，不包括'在内。另外，strlen函数也可以直接测试字符串常量的长度，如：strlen(“Welcome”)。

void *memset(void *dest, int c, size_t count);

将dest前面count个字符置为字符c.返回dest的值.void *memmove(void *dest, const void *src, size_t count);

从src复制count字节的字符到dest.如果src和dest出现重叠, 函数会自动处理.返回dest的值.void *memcpy(void *dest, const void *src, size_t count);

从src复制count字节的字符到dest.与memmove功能一样, 只是不能处理src和dest出现重叠.返回dest的值.void *memchr(const void *buf, int c, size_t count);在buf前面count字节中查找首次出现字符c的位置.找到了字符c或者已经搜寻了count个字节, 查找即停止.操作成功则返回buf中首次出现c的位置指针, 否则返回NULL.void *_memccpy(void *dest, const void *src, int c, size_t count);

从src复制0个或多个字节的字符到dest.当字符c被复制或者count个字符被复制时, 复制停止.如果字符c被复制, 函数返回这个字符后面紧挨一个字符位置的指针.否则返回NULL.int memcmp(const void *buf1, const void *buf2, size_t count);

比较buf1和buf2前面count个字节大小.返回值< 0, 表示buf1小于buf2;

返回值为0, 表示buf1等于buf2;

返回值> 0, 表示buf1大于buf2.int memicmp(const void *buf1, const void *buf2, size_t count);

比较buf1和buf2前面count个字节.与memcmp不同的是, 它不区分大小写.返回值同上.char *strrev(char *string);

将字符串string中的字符顺序颠倒过来.NULL结束符位置不变.返回调整后的字符串的指针.char *_strupr(char *string);

将string中所有小写字母替换成相应的大写字母, 其它字符保持不变.返回调整后的字符串的指针.char *_strlwr(char *string);

将string中所有大写字母替换成相应的小写字母, 其它字符保持不变.返回调整后的字符串的指针.char *strchr(const char *string, int c);

查找字

串string中首次出现的位置, NULL结束符也包含在查找中.返回一个指针, 指向字符c在字符串string中首次出现的位置, 如果没有找到, 则返回NULL.char *strrchr(const char *string, int c);

查找字符c在字符串string中最后一次出现的位置, 也就是对string进行反序搜索, 包含NULL结束符.返回一个指针, 指向字符c在字符串string中最后一次出现的位置, 如果没有找到, 则返回NULL.char *strstr(const char *string, const char *strSearch);

在字符串string中查找strSearch子串.返回子串strSearch在string中首次出现位置的指针.如果没有找到子串strSearch, 则返回NULL.如果子串strSearch为空串, 函数返回string值.char *strdup(const char *strSource);

函数运行中会自己调用malloc函数为复制strSource字符串分配存储空间, 然后再将strSource复制到分配到的空间中.注意要及时释放这个分配的空间.返回一个指针, 指向为复制字符串分配的空间;如果分配空间失败, 则返回NULL值.char *strcat(char *strDestination, const char *strSource);

将源串strSource添加到目标串strDestination后面, 并在得到的新串后面加上NULL结束符.源串strSource的字符会覆盖目标串strDestination后面的结束符NULL.在字符串的复制或添加过程中没有溢出检查, 所以要保证目标串空间足够大.不能处理源串与目标串重叠的情况.函数返回strDestination值.char *strncat(char *strDestination, const char *strSource, size_t count);

将源串strSource开始的count个字符添加到目标串strDest后.源串strSource的字符会覆盖目标串strDestination后面的结束符NULL.如果count大于源串长度, 则会用源串的长度值替换count值.得到的新串后面会自动加上NULL结束符.与strcat函数一样, 本函数不能处理源串与目标串重叠的情况.函数返回strDestination值.char *strcpy(char *strDestination, const char *strSource);

复制源串strSource到目标串strDestination所指定的位置, 包含NULL结束符.不能处理源串与目标串重叠的情况.函数返回strDestination值.char *strncpy(char *strDestination, const char *strSource, size_t count);

将源串strSource开始的count个字符复制到目标串strDestination所指定的位置.如果count值小于或等于strSource串的长度, 不会自动添加NULL结束符目标串中, 而count大于strSource串的长度时, 则将strSource用NULL结束符填充补齐count个字符, 复制到目标串中.不能处理源串与目标串重叠的情况.函数返回strDestination值.char *strset(char *string, int c);

将string串的所有字符设置为字符c, 遇到NULL结束符停止.函数返回内容调整后的string指针.char *strnset(char *string, int c, size_t count);

将string串开始count个字符设置为字符c, 如果count值大于string串的长度, 将用string的长度替换count值.函数返回内容调整后的string指针.size_t strspn(const char *string, const char *strCharSet);

查找任何一个不包含在strCharSet串中的字符(字符串结束符NULL除外)在string串中首次出现的位置序号.返回一个整数值, 指定在string中全部由characters中的字符组成的子串的长度.如果string以一个不包含在strCharSet中的字符开头, 函数将返回0值.size_t strcspn(const char *string, const char *strCharSet);

查找strCharSet串中任何一个字符在string串中首次出现的位置序号, 包含字符串结束符NULL.返回一个整数值, 指定在string中全部由非characters中的字符组成的子串的长度.如果string以一个包含在strCharSet中的字符开头, 函数将返回0值.char *strspnp(const char *string, const char *strCharSet);

查找任何一个不包含在strCharSet串中的字符(字符串结束符NULL除外)在string串中首次出现的位置指针.返回一个指针, 指向非strCharSet中的字符在string中首次出现的位置.char *strpbrk(const char *string, const char *strCharSet);

查找strCharSet串中任何一个字符在string串中首次出现的位置, 不包含字符串结束符NULL.返回一个指针, 指向strCharSet中任一字符在string中首次出现的位置.如果两个字符串参数不含相同字符, 则返回NULL值.int strcmp(const char *string1, const char *string2);

比较字符串string1和string2大小.返回值< 0, 表示string1小于string2;

返回值为0, 表示string1等于string2;

返回值> 0, 表示string1大于string2.int stricmp(const char *string1, const char *string2);

比较字符串string1和string2大小，和strcmp不同, 比较的是它们的小写字母版本.返回值与strcmp相同.int strcmpi(const char *string1, const char *string2);

等价于stricmp函数, 只是提供一个向后兼容的版本.int strncmp(const char *string1, const char *string2, size_t count);

比较字符串string1和string2大小，只比较前面count个字符.比较过程中, 任何一个字符串的长度小于count, 则count将被较短的字符串的长度取代.此时如果两串前面的字符都相等, 则较短的串要小.返回值< 0, 表示string1的子串小于string2的子串;

返回值为0, 表示string1的子串等于string2的子串;

返回值> 0, 表示string1的子串大于string2的子串.int strnicmp(const char *string1, const char *string2, size_t count);

比较字符串string1和string2大小，只比较前面count个字符.与strncmp不同的是, 比较的是它们的小写字母版本.返回值与strncmp相同.char *strtok(char *strToken, const char *strDelimit);

在strToken 串中查找下一个标记, strDelimit字符集则指定了在当前查找调用中可能遇到的分界符.返回一个指针, 指向在strToken中找到的下一个标记.如果找不到标记, 就返回NULL值.每次调用都会修改strToken内容, 用NULL字符替换遇到的每个分界符.c++概念字符串操作

一、char_traits 字符特征类

1）意义：包装特定串元素的通用行为界面，以便容器实现时依据特征信息而执行特定行为

2）定义了通用类型名

typedef _Elem char_type;typedef int int_type;

typedef streampos pos_type;typedef streamoff off_type;typedef mbstate_t state_type;

其中 int_type 表示字符元素转换到特定编码时的整型表示，pos_type, off_type 分别作为字符串索引和字符串元素偏移的类型，类似容器迭中的指针，迭代类型和指针，迭代器的偏移类型。最后的 state_type 用于存储流状态，如出错，格式控制等等。

3）定义了字符 / 字符串操作的包装界面，以便通用算法的调用

assign(a, b)定义将 b 字符赋值给 a 字符的过程，实现 a.operator = 的行为

eq(a, b)定义 a 字符和 b 字符的相等关系，实现 a.operator == 的行为

lt(a, b)定义 a 小于 b 的关系，实现 a.operator < 的行为

compare(a_ptr, b_ptr, cnt)定义两组字符串的比较，返回 int 类型，实现类似 memcmp 的行为

length(ptr)定义取字符串长度，实现类似 strlen 的行为

copy(a_ptr, b_ptr, cnt)定义两组字符串的复制，实现类似 memcpy 的行为

move(a_ptr, b_ptr, cnt)定义两组字符串的不重叠复制，实现类似 memmove 的行为

assign(ptr, cnt, ch)定义了填充字符串的过程，实现类似 memset 的行为

to_int_type(ch)定义了 char_type 到 int_type 整型的转换过程

to_char_type(n)定义了 int_type 到 char_type 字符型的转换过程

eq_int_type(a, b)定义两个和当前 char_type 类型对应的 int_type 的相等关系

eof()定义字符串结尾符，使用整型表示

not_eof(n)定义非字符串结尾符，若输入结尾符，则返回 1，其他输入返回原值，即总是不返回 eof()

4）int_type 类型应是当前字符类型的整型编码

二、std::string 并不是序列容器，没有 front()和 back()界面用于取出前端和尾端的元素，使用 std::string::operator [] 并传递 streampos 类型取得特定元素，如 std::string::size()-1 作为索引取得最后一个字符

三、basic_string 支持的初始化

1）默认初始化

2）分配器

3）复制构造

4）局部复制 [_Roff, _Roff + _Count)5）局部复制 + 分配器

6）C 字符串 [_Ptr, )

7）C 字符串 + _Count [_Ptr, _Ptr + _Count)8）C 字符串 + 分配器

9）C 字符串 + _Count + 分配器 [_Ptr, _Ptr + _Count)10）_Count * _Ch

11）_Count * _Ch + 分配器

12）迭代器 [_ItF, _ItL)13）迭代器 + 分配器

字符到串不能初始化，但支持 operator = 赋值和 operator += 累加赋值运算。

四、字符串的区间有效性 对串的索引访问在超过字符串的有效区间时，因为串的在实现上对内置的字符缓冲区执行下标访问，所以不会导致异常，但是将得到不可预知的结果，通常是不可用的。将其他字符串作为右值输入时，对该串取出计数大于串大小时按串大小计算。

std::basic_string::size_type 的实际类型为 size_t，在 Visual C++ 7.1 中实现为 unsigned，std::basic_string::npos 被静态设定为

(basic_string<_Elem, _Traits, _Alloc>::size_type)(-1);

在查找子字符串等操作时，函数返回 npos 的值表示非法索引。

五、比较字符串

允许的比较对象

1）compare(s2)其他同类型字符串

2）compare(p)C 风格字符串

3）compare(off, cnt, s2)[off, off + cnt)同 s2 执行比较

4）compare(off, cnt, s2, off2, cnt2)[off, off + cnt)同 s2 [off2, cnt2)执行比较

5）compare(off, cnt, p)[off, off + cnt)同 [p , )执行比较

6）compare(off, cnt, p, cnt2)[off, off + cnt)同 [p, p + cnt2)执行比较

返回-1, 0, 1 作为小于、等于和大于的比较结果。

六、附加数据

1）使用 operator += 接受其他字符串，C 风格字符串和字符

2）使用 push_back()在尾部附加字符，并使得通过字符串构造的 back_iterator 可以访问

3）append()附加

1、append(s)追加字符串

2、append(s, off, cnt)追加字符串 s [off, off + cnt)

3、append(p)追加字符串 [p, )

4、append(p, cnt)追加字符串 [p, p + cnt)

5、append(n, c)填充 n * c

6、append(InF, InL)追加输入流 [InF, InL)

4）insert()插入

1、insert(off, s2)插入字符串

2、insert(off, s2, off2, cnt2)插入字符串 s [off2, off2 + cnt2)

3、insert(off, p)插入字符串 [p, )

4、insert(off, p, cnt)插入字符串 [p, p + cnt)

5、insert(off, n, c)插入 n * c

6、insert(iter)元素默认值填充

7、insert(iter, c)插入特定元素

8、insert(iter, n, c)插入 n*c

9、insert(iter, InF, InL)插入 [InF, InL)

5）operator +(a, b)

字符串关联运算符重载中支持 operator + 的形式

1、s + s

2、s + p

3、s + c

4、p + s

5、c + s

七、查找、替换和清除

1）find()查找

1、find(c, off)在 s [off, npos)中查找 c

2、find(p, off, n)在 s [off, npos)中查找 [p, p + n)

3、find(p, off)在 s [off, npos)中查找 [p, )

4、find(s2, off)在 s [off, npos)中查找 s2

2）find()的变种

1、rfind()具有 find()的输入形式，反序查找

2、find_first_of()具有 find()的输入形式，返回第一个匹配的索引

3、find_last_of()具有 find()的输入形式，返回倒数第一个匹配的索引

4、find_first_not_of()具有 find()的输入形式，返回第一个不匹配的索引

5、find_last_not_of()具有 find()的输入形式，返回倒数第一个不匹配的索引

3）replace()替换

1、replace(off, cnt, s2)将 s [off, off + cnt)替换成 s2

2、replace(off, cnt, s2, off2, cnt2)将 s [off, off + cnt)替换成 s2 [off2, off2 + cnt2)

3、replace(off, cnt, p)将 s [off, off + cnt)替换成 [p, )

4、replace(off, cnt, p, cnt2)将 s [off, off + cnt)替换成 [p, p + cnt2)

5、replace(off, cnt, n, c)将 s [off, off + cnt)替换成 c * n

使用迭代器的情况：

6、replace(InF, InL, s2)将 [InF, InL)替换成 s2

7、replace(InF, InL, p)将 [InF, InL)替换成 [p, )

8、replace(InF, InL, p, cnt)将 [InF, InL)替换成 [p, p + cnt)

9、replace(InF, InL, n, c)将 [InF, InL)替换成 n * c

10、replace(InF, InL, InF2, InL2)将 [InF, InL)替换成 [InF2, InL2)

4）erase()删除

1、erase(off, cnt)从字符串 s 中删除 s [off, off + cnt)

2、erase(iter)从字符串 s 中删除 *iter

3、erase(ItF, ItL)从字符串 s 中删除 [ItF, ItL)

八、取出字符串

1）取得 C 风格字符串

c_str()返回常量类型的 C 风格字符串指针，copy(ptr, cnt, off = 0)则将指定大小的字符串复制到特定指针。data()在 Visual C++ 7.1 中仅仅调用了 c_str()实现。

2）取得子字符串

substr(off, cnt)取得 s [off, off + cnt)的副本。

3）复制子字符串

copy(p, off, cnt)将 s [off, off + cnt)复制到 p。

九、字符串的缓冲区管理

字符串具有类似 std::vector 的缓冲区管理界面。

size()取得有效元素长度

max_size()取得当前内存分配器能分配的有效空间

reserve()为缓冲区预留空间 capacity()取得缓冲区的容量

resize()重设串的长度，可以为其指定初始化值

十、定义输入迭代器的尾端

向 istream_iterator 传递输入流对象以创建输入迭代器，输入迭代器持有输入流对象的指针，默认创建和读取流失败的情况下该指针被设置为 0。并且在实现输入迭代器间的 operator == 相等运算时，进行持有的流对象指针的相等比较，这样，默认创建的输入迭代器将被用于匹配输入流的结束。

篇3：C语言中文件操作的基本操作

在文件操作之前的章节中, 程序中的输入数据都来源于键盘, 而输出数据都是输出到屏幕上的。而这里的输入数据是来源于文件, 而输出结果是输出到文件的。

而在现实之中往往是把数据从文件中读出, 然后经过处理, 再将结果输出到某个文件中保存起来, 这就是文件的操作。

文件的操作包括, 打开与关闭文件, 文件定位函数, 文件管理函数等。本文主要先介绍文件的打开与关闭应注意的问题。

1 文件的打开

什么是文件的打开呢?其实就是为文件建立相应的信息区和文件缓冲区。

所谓文件的信息区:

而文件的缓冲区是:

文件的打开方法是调用fopen函数。

具体如下:

首先定义指向文件型的指针fp:

下面通过实例来看看它们之间的区别。

首先看一看通过“r”方式打开文件。如果在工程文件夹下已有文件test1.txt, 其内容为:“C语言文件操作”, 使用“r”方式将test1.txt文件打开, 程序段如下:

运行结果为:

press any key to contimue

我们在操作系统下把test1.txt打开, 来看一看。里面的内容仍是“C语言文件操作”。

同样使用“r”方式打开一个并不存在的文件test2.txt, 看看结果怎样?

运行结果为:

open file error!

press any key to contimue

说明使用“r”方式只能打开已存在的文件, 而不能打开并不存在的文件, 否则出错。

那么我们看一看通过“w”方式打开文件。

文件正常打开。我们回到工程文件夹, 可以看到, 原本不存在的test2.txt出现了。说明原本不存在的文件, 则在打开时新建一个指定的名字 (这里是test2.txt) 命名的文件。而使用“r”方式则不能。

接下来, 我们看一看, 使用“w”方式打开已经存在的文件test1.txt, 是不是没有区别呢?

运行结果为:

press any key to contimue

文件正常打开了。

我们回到操作系统, 将test1.txt打开, 看一看它里面的内容, 发现test1.txt里面的内容全部删除了。

说明用“w”方式打开原来已经存在的文件, 则在打开时先将该文件删除, 然后重新建立一个指定文件名 (这里是test1.txt) 的新文件。

那么如果我们要在已有的文件中添加新的数据怎么办呢?在这种情况下通过“a”方式来打开文件。下面是使用“a”方式打开原来的文件test1.txt, 里面的内容是:“C语言文件操作”, 代码如下:

运行结果为:

press any key to contimue

文件正常打开。我们回到工程文件夹, 打开test1.txt, 看到里面的内容仍是“C语言文件操作”。说明如果想向文件的末尾添加新的数据而不删除原来数据, 则应使用“a”方式打开文件。

2 文件的关闭

文件在使用完以后, 一定要关闭文件。关闭就是撤销文件信息区和文件缓冲区, 使文件指针变量不再指向该文件。

方法是用fclose函数关闭文件。假设fp是指向文件的指针, 关闭fp所指向文件的语句为:fclose (fp) ;

为什么使用完文件一定要关闭呢?因为, 在向文件写数据时, 是先将数据输出到缓冲区, 待缓冲区充满后才正式输出给文件。如果当数据未充满缓冲区而程序运行结束, 就会将缓冲区中的数据丢失。而使用fclose关闭文件, 就可以避免这一问题, 它的作用是先将缓冲区中的数据输出到磁盘文件, 然后才释放文件指针变量。

篇4：c语言位操作总结

语言位运算符：与、或、异或、取反、左移和右移

位运算是指按二进制进行的运算。在系统软件中，常常需要处理二进制位的问题。C语言提供了6个位操作运算符。这些运算符只能用于整型操作数，即只能用于带符号或无符号的char,short,int与long类型。C语言提供的位运算符列表： 运算符 含义 描述

& 按位与 如果两个相应的二进制位都为1，则该位的结果值为1，否则为0 | 按位或 两个相应的二进制位中只要有一个为1，该位的结果值为1 ^ 按位异或 若参加运算的两个二进制位值相同则为0，否则为1 ~ 取反 ~是一元运算符，用来对一个二进制数按位取反，即将0变1，将1变0 << 左移 用来将一个数的各二进制位全部左移N位，右补0 >> 右移 将一个数的各二进制位右移N位，移到右端的低位被舍弃，对于无符号数，高位补0

1、“按位与”运算符（&）

按位与是指：参加运算的两个数据，按二进制位进行“与”运算。如果两个相应的二进制位都为１，则该位的结果值为1；否则为0。这里的1可以理解为逻辑中的true,0可以理解为逻辑中的false。按位与其实与逻辑上“与”的运算规则一致。逻辑上的“与”，要求运算数全真，结果才为真。若，A=true,B=true,则A∩B=true 例如：3&5 3的二进制编码是11(2)。（为了区分十进制和其他进制，本文规定，凡是非十进制的数据均在数据后面加上括号，括号中注明其进制，二进制则标记为2）内存储存数据的基本单位是字节（Byte），一个字节由8个位（bit)所组成。位是用以描述电脑数据量的最小单位。二进制系统中，每个0或1就是一个位。将11（2）补足成一个字节，则是00000011（2）。5的二进制编码是101（2），将其补足成一个字节，则是00000101（2）按位与运算： 00000011(2)&00000101(2)00000001(2)由此可知3&5=1 c语言代码：

#include main(){ int a=3;int b = 5;printf(“%d”,a&b);} 按位与的用途：（1）清零

若想对一个存储单元清零，即使其全部二进制位为0，只要找一个二进制数，其中各个位符合一下条件：

原来的数中为1的位，新数中相应位为0。然后使二者进行&运算，即可达到清零目的。

例：原数为43，即00101011（2），另找一个数，设它为148，即10010100（2），将两者按位与运算： 00101011（2）&10010100（2）00000000（2）c语言源代码： #include main(){ int a=43;int b = 148;printf(“%d”,a&b);}（2）取一个数中某些指定位

若有一个整数a(2byte),想要取其中的低字节，只需要将a与8个1按位与即可。a 00101100 10101100 b 00000000 11111111 c 00000000 10101100（3）保留指定位：

与一个数进行“按位与”运算，此数在该位取1.例如：有一数84，即01010100（2），想把其中从左边算起的第3，4，5，7，8位保留下来，运算如下： 01010100(2)&00111011(2)00010000(2)即：a=84,b=59 c=a&b=16 c语言源代码： #include main(){ int a=84;int b = 59;printf(“%d”,a&b);}

2、“按位或”运算符（|）

两个相应的二进制位中只要有一个为1，该位的结果值为1。借用逻辑学中或运算的话来说就是，一真为真。

例如：60（8）|17（8）,将八进制60与八进制17进行按位或运算。00110000 |00001111 00111111 c语言源代码： #include main(){ int a=060;int b = 017;printf(“%d”,a|b);} 应用：按位或运算常用来对一个数据的某些位定值为1。例如：如果想使一个数a的低4位改为1，则只需要将a与17（8）进行按位或运算即可。

３、交换两个值，不用临时变量

例如：ａ＝３，即11（2）；ｂ＝４，即100（2）。想将ａ和ｂ的值互换，可以用以下赋值语句实现：

ａ＝a∧b;ｂ＝b∧a;ａ＝a∧b;ａ＝011(2)（∧）ｂ＝100(2)ａ＝111(2)（a∧b的结果，a已变成７）

（∧）ｂ＝100(2)ｂ＝011(2)（b∧a的结果，b已变成３）

（∧）ａ＝111(2)

ａ＝100（2）（a∧b的结果，a已变成４）等效于以下两步： ① 执行前两个赋值语句：“ａ＝ａ∧ｂ；”和“ｂ＝ｂ∧ａ；”相当于b=b∧(a∧b)。

② 再执行第三个赋值语句： ａ＝ａ∧ｂ。由于a的值等于（ａ∧ｂ），b的值等于（ｂ∧ａ∧ｂ），因此，相当于a=ａ∧ｂ∧ｂ∧ａ∧ｂ，即a的值等于ａ∧ａ∧ｂ∧ｂ∧ｂ，等于ｂ。很神奇吧！c语言源代码： #include main(){ int a=3;int b = 4;a=a^b;b=b^a;a=a^b;printf(“a=%d b=%d”,a,b);}

4、“取反”运算符（~）

他是一元运算符，用于求整数的二进制反码，即分别将操作数各二进制位上的1变为0，0变为1。例如：~77(8)源代码：

#include main(){ int a=077;printf(“%d”,~a);}

5、左移运算符（<<）

左移运算符是用来将一个数的各二进制位左移若干位，移动的位数由右操作数指定（右操作数必须是非负

值），其右边空出的位用0填补，高位左移溢出则舍弃该高位。

例如：将a的二进制数左移2位，右边空出的位补0，左边溢出的位舍弃。若a=15,即00001111（2），左移2 位得00111100（2）。源代码：

#include main(){ int a=15;printf(“%d”,a<<2);} 左移1位相当于该数乘以2，左移2位相当于该数乘以2*2＝4,15＜＜2=60，即乘了４。但此结论只适用于该

数左移时被溢出舍弃的高位中不包含1的情况。

假设以一个字节（８位）存一个整数，若ａ为无符号整型变量，则ａ＝64时，左移一位时溢出的是0，而左移2位时，溢出的高位中包含1。

6、右移运算符（>>）

右移运算符是用来将一个数的各二进制位右移若干位，移动的位数由右操作数指定（右操作数必须是非负

值），移到右端的低位被舍弃，对于无符号数，高位补0。对于有符号数，某些机器将对左边空出的部分

用符号位填补（即“算术移位”），而另一些机器则对左边空出的部分用0填补（即“逻辑移位”）。注 意：对无符号数,右移时左边高位移入0；对于有符号的值,如果原来符号位为0(该数为正),则左边也是移

入0。如果符号位原来为1(即负数),则左边移入0还是1,要取决于所用的计算机系统。有的系统移入0,有的

系统移入1。移入0的称为“逻辑移位”,即简单移位；移入1的称为“算术移位”。例： a的值是八进制数113755：

a:***1（用二进制形式表示）

a>>1: ***0(逻辑右移时)a>>1: ***0(算术右移时)在有些系统中,a>>1得八进制数045766,而在另一些系统上可能得到的是145766。Turbo C和其他一些C 编译采用的是算术右移,即对有符号数右移时,如果符号位原来为1，左面移入高位的是1。源代码：

#include main(){ int a=0113755;printf(“%d”,a>>1);}

7、位运算赋值运算符

位运算符与赋值运算符可以组成复合赋值运算符。

篇5：c语言中字符串操作的工具类

#define _CRT_SECURE_NO_WARNINGS

//#pragmawarning(disable:4996)

#include

#include

#include

struct CString

{

char *p; //保存字符串首地址

int reallength; //实际长度

};

typedef struct CString mystring;//简写

//原封不动初始化

void init(mystring *string);

//开辟长度，内存清零

void initwithlength(mystring *string, int length);

//初始化并拷贝字符串

void initwithstring(mystring *string, char *copystring);

//打印

void printfstring(mystring *string);

//增加字符

void backaddchar(mystring *string, char ch);

//增加字符串

void backaddstring(mystring *string, char*str);

//执行指令

void run(mystring *string);

//返回第一个找到的字符的地址

char * findfirstchar(mystring *string, char ch);

//返回第一个找到的字符串的地址

char * findfirststring(mystring *string, char *str);

//删除第一个找到的字符

int deletefirstchar(mystring *string, const char ch);

//删除第一个找到的字符串

int deletefirststring(mystring *string, char * const str);

//任意增加字符

void addchar(mystring *string, char ch, char *pos);

//任意增加字符串

void addstring(mystring *string, char*str, char *pos);

//改变字符

void changefirstchar(mystring *string, const char oldchar, const char newchar);

//改变字符串

void changefirststring(mystring *string, char * const oldstring, char *const newstring);

2.编写函数实现

#include “mystring.h”

#include “stdio.h”

#include “stdlib.h”

/* 求字符串的长度 */

int mystrlen(char *p)

{

if (p == NULL)

{

return -1;//失败，

}

int length = 0;

while (*p != ')//字符串终止条件

{

length++;//长度自增

p++;//指针不断向前

}

return length;

}

/*字符串拷贝 */

char *mystrcpy(char *dest, const char *source)//const限定不被意外修改

{

if (dest == NULL || source == NULL)

{

return NULL;//为空没有必要干活了

}

char * destbak = dest;

while (*source != ')//一直拷贝

{

*dest = *source;//赋值字符

source++;

dest++;//指针不断向前，字符挨个赋值

}

*dest = ';//结尾

return destbak;//返回地址

}

/*字符串拼接*/

char *mystrcat(char *dest, const char *source)

{

if (dest == NULL || source == NULL)

{

return NULL;//失败

}

else

{

char *destbak = dest;//保留地址

while (*dest != ')

{

dest++;//指针向前移动

}

//从尾部开始拷贝

while (*source != ') //循环被被拷贝的字符串

{

*dest = *source;//字符串赋值

dest++;

source++;

}

*dest = ';//结尾

return destbak;

}

}

char * mystrchr(const char *dest, const char ch)

{

if (dest == NULL)

{

return NULL;

}

while (*dest != ')

{

if (*dest == ch)

{

return dest;//找到返回地址

}

dest++;

}

return NULL;//返回

}

char *mystrstr(const char * const dest, const char * const findstr)

{

if (dest == NULL || findstr == NULL)

{

return NULL;

}

char *destbak = dest;

char *p = NULL;//保存找到的地址

while (*destbak != ')

{

int flag = 1;//假定是相等

char *findstrbak = findstr;

char *nowdestbak = destbak;

while (*findstrbak != ')

{

if (*nowdestbak != ')

{

if (*findstrbak != *nowdestbak)//有一个不等

{

flag = 0;//赋值为0代表不等

}

nowdestbak++;

findstrbak++;

}

else

{

flag = 0;//设置标识

break;

}

}

if (flag == 1)

{

p = destbak;//当前位置

return p;

}

destbak++;

}

return NULL;

}

void init(mystring *string)

{

string->p = NULL;

string->reallength = 0;//初始化结构体字符串

}

void initwithlength(mystring *string, int length)

{

//string->p =(char *) malloc(sizeof(char)*length);//分配内存

string->p = (char *)calloc(length, sizeof(char));//分配内存并清零

string->reallength = length;//长度

}

void initwithstring(mystring *string, char *copystring)

{

int length = strlen(copystring);//获取字符串长度

string->p = (char *)calloc(length + 1, sizeof(char));//分配内存

mystrcpy(string->p, copystring);//拷贝字符串

string->reallength = length + 1;//设置长度

}

void backaddchar(mystring *string, char ch)

{

if (mystrlen(string->p) + 1 == string->reallength)//意味着满了

{

//重新分配内存