#include <stdio.h>
#include <stdlib.h>
int main(int argc,char **argv)
{
FILE *fp = fopen("./a.txt","a"); //add pattern
if(fp == NULL){
printf("open file failed\n");
return -1;
}
printf("open file successful\n");
//write characters to file
fputc('A',fp);
fputc('b',fp);
fputc('c',fp);
fputc('d',fp);
fputc('e',fp);
fputc('f',fp);
fputc('g',fp);
fputc('i',fp);
fputc('h',fp);
printf("write to file successful\n");
fclose(fp);
printf("start to read file\n");
FILE *rp = fopen("./a.txt","r");
if(rp == NULL){
printf("open file failed");
return -1;
}
char c;
while((c=fgetc(rp)) != EOF){
printf("%c\n",c);
}
fclose(rp);
return 0;
}
vi命令
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc,char **argv)
{
char fileName[256];
printf("请输入要创建的文件名\n");
scanf("%s",fileName);
getchar(); //保持输入状态
FILE *fp = fopen(fileName,"w"); //找不到文件自己创建
if(fp == NULL){
printf("创建文件失败");
return -1;
}
//定义一个缓冲区
char buff[1024];
while(1){
memset(buff,0,1024); //1k内存全部置为空 重置缓冲区
//读取用户输入的内容
fgets(buff,1024,stdin);
if(strncmp("exit",buff,4) == 0){
break;
}
int i=0;
while(buff[i] != '\0'){
fputc(buff[i++],fp);
}
}
//关闭文件操作符
fclose(fp);
return 0;
}
cat 命令
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc,char **argv)
{
char fileName[256];
printf("请输入要打开的文件名\n");
scanf("%s",fileName);
getchar(); //保持输入状态
FILE *fp = fopen(fileName,"r"); //找不到文件自己创建
if(fp == NULL){
printf("打开文件失败");
return -1;
}
char str;
while( (str = fgetc(fp)) != EOF){
printf("%c",str);
}
//关闭文件操作符
fclose(fp);
return 0;
}
文件行读取
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc,char **argv)
{
char fileName[256];
printf("请输入要打开的文件名\n");
scanf("%s",fileName);
FILE *fp = fopen(fileName,"r"); //找不到文件自己创建
if(fp == NULL){
printf("打开文件失败");
return -1;
}
char *str = malloc(sizeof(char)*1024);
while( feof(fp) == 0){
memset(str,0,1024);
fgets(str,1024,fp);
printf("%s",str);
}
//关闭文件操作符
fclose(fp);
return 0;
}
对10w条随机整型数据进行排序
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(int argc, char **argv)
{
/*******生成随机数10w个一千以内的随机数*********/
unsigned int wst = time(NULL);
unsigned int wet;
unsigned int tc;
unsigned int tcall;
//随机数种子
srand((unsigned int )time(NULL));
//新建文件
FILE *fp = fopen("./5.txt","w"); //可以用输入方式打开新建文件
if(!fp){
printf("Can not open file 5.txt");
}
//打开文件成功 写入10w个随机数
for(int i=0;i<100000;i++){
fprintf(fp,"%d\n",rand()%1000+1); //写入文件中
}
fclose(fp); //关闭文件
wet = time(NULL);
tc = wet - wst;
printf("生成随机数消耗时间%d(s)\n",tc);
/*****************使用快速排序对10W个数据排序 耗时52秒 win7 8G内存 **************************/
FILE *rp = fopen("./5.txt","r");
if(!rp){
printf("can not open file 5.txt");
return -1;
}
//读取数据到内存中
int *buff = (int *)malloc(sizeof(int)*100000); //开辟一个可以存放10W个数据的内存空间
//读取10次数据存放到堆中
for(int i=0;i<100000;i++){
fscanf(rp,"%d\n",&buff[i]); //注意第三个参数是用指针传递地址 方便快捷 节省空间
}
//数据已经放到内存中 从内存中拿出来 用快速排序实现数据的排序 然后重新写入到5.txt
for(int i=0;i<100000-1;i++){ //对堆内存中的数据排好序
for(int j=0;j<100000-i-1;j++){
if(buff[j] > buff[j+1]){
int temp = buff[j+1];
buff[j+1] = buff[j];
buff[j] = temp;
}
}
}
FILE *wp = fopen("./5.txt","w");
if(!wp){
printf("can not open file");
return -1;
}
//重新写入到原文件中
for(int i=0;i<100000;i++){
fprintf(wp,"%d\n",buff[i]);
}
tcall = time(NULL);
printf("总共消耗了%d(s)\n",tcall - wst);
fclose(wp);
free(buff); //释放空间
/************使用优化的方法来排序 耗时1秒*********/
/*
* 对10w条数据统计
*统计1-1000之内数字出现的次数
*arr[1] = xxx
*arr[1000] = xxxx
*记录 然后打印
*/
FILE *rp1 = fopen("./5.txt","r");
if(!rp1){
printf("can not open file 5.txt");
return -1;
}
int arr[1000]={0};
int value;
//用一个双层循环统计次数
for(int i=0;i<100000;i++){
fscanf(rp1,"%d\n",&value);
arr[value - 1]++;
}
fclose(rp1);
rp1 = fopen("./5.txt","w");
if(!rp1){
printf("can not open file 5.txt");
return -1;
}
//用循环打印所有的数据
for(int i=0;i<1000;i++){
for(int j=0;j<arr[i];j++){
fprintf(rp1, "%d\n",i+1);
}
}
fclose(rp1);
return 0;
}
fwrite 和fread 读取文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc , char **argv)
{
//二进制文件读写
char arr[30] = "woaiwodezuoguozhongguo";
FILE *fp = fopen("./6.txt","wb");
if(!fp){
printf("failed to open file");
return -1;
}
fwrite(arr,sizeof(char),30,fp);
//再用fread 去读取 打印
fclose(fp);
return 0;
}
大文件拷贝 类似Linux 下面的copy命令(简单版)
#include <stdio.h> #include <stdlib.h> #include <string.h> #include<time.h> #define MAXSIZE 1024*10 int main(int argc ,char *argv[]) { //文件拷贝 //fgets fputs //fread fwrite unsigned int start_time = time(NULL); if(argc < 3){ printf("Error:less paramters"); return -1; } FILE *fp1 = fopen("./1.mp4","rb"); FILE *fp2 = fopen("./2.mp4","wb"); if(!fp1 || !fp2){ printf("Error:open file failed"); return -1; } //fgets and fputs 拷贝文件 但是会丢失内容消耗时间特别长 例如会导致视频播放不了 char buff[MAXSIZE]; while(!feof(fp1)){ fgets(buff,MAXSIZE,fp1); fputs(buff,fp2); } /***fread and fwrite 这个比较可靠实现**/ char *buff = (char*)malloc(MAXSIZE); int readCount; while( (readCount = fread(buff,1,MAXSIZE,fp1)) > 0){ fwrite(buff,readCount,1,fp2); } free(buff); fclose(fp1); fclose(fp2); unsigned int end_time = time(NULL); printf("All consume time is %d(s)\n",end_time - start_time); return 0; }
fseek SEEK_SET SEEK_END SEEK_CUR 设置文件的光标位置
ftell 获取当前文件的光标位置
rewind 重置文件指针为初始位置
进阶
typedef
char *p1,p2; 不能同时定义两个char*
typedef char * PCHAR;
PCHAR P1,P2; 可以定义两个char*
void 是对函数返回的限定和函数参数的限定
void function(){}
int function(void){}
void * 可以表示任何类型的指针 不管是一级还是二级 还是多级 int*还是char*都可以表示 也就是可以转换成void* 类型 一般用于数据结构的封装(指针的祖宗)
这是给编译器用的参数设置,有关结构体字节对齐方式设置, #pragma pack是指定数据在内存中的对齐方式。
#pragma pack (n) 作用:C编译器将按照n个字节对齐。
#pragma pack () 作用:取消自定义字节对齐方式。
#pragma pack (push,1) 作用:是指把原来对齐方式设置压栈,并设新的对齐方式设置为一个字节对齐
#pragma pack(pop) 作用:恢复对齐状态
因此可见,加入push和pop可以使对齐恢复到原来状态,而不是编译器默认,可以说后者更优,但是很多时候两者差别不大
如:
#pragma pack(push) //保存对齐状态
#pragma pack(4)//设定为4字节对齐
相当于 #pragma pack (push,4)
间接赋值
int a = 100;
int *p = &a; //一定要确保地址没有被释放
*p = 200; //赋值
#pragma pack (1) 作用:调整结构体的边界对齐,让其以一个字节对齐;<使结构体按1字节方式对齐>
#pragma pack ()
堆区
解决办法 :
void allocateSpace(char **p) //参数是一个地址
{
temp = NULL;
temp = malloc(100);
strcpy(temp,"hello world");
*p = temp;
}
void test02()
{
char *p = NULL;
allocateSpace(&p); //参数是一个地址
printf("p=%s\n",p);
}
宏和函数的区别,C语言宏和函数区别详解
在 C 语言中,对于一些常用或通用的功能或代码段的封装可以有两种方式:函数和宏定义。那么,对于这两种方式,我们该如何抉择呢?在解决这个问题之前,有必要先来了解一下它们之间的区别。
1) 从程序的执行来看
函数调用会带来额外的开销,它需要开辟一片栈空间,记录返回地址,将形参压栈,从函数返回还要释放栈。这种开销不仅会降低代码效率,而且代码量也会大大增加。而宏定义只在编译前进行,不分配内存,不占运行时间,只占编译时间,因此在代码规模和速度方面都比函数更胜一筹。
2) 从参数的类型来看
函数的参数必须声明为一种特定的数据类型,如果参数的类型不同,就需要使用不同的函数来解决,即使这些函数执行的任务是相同的。而宏定义则不存在着类型问题,因此它的参数也是无类型的。也就是说,在宏定义中,只要参数的操作是合法的,它可以用于任何参数类型。
3) 从参数的副作用来看
毋庸置疑,在宏定义中,在对宏参数传入自增(或者自减)之类的表达式时很容易引起副作用,尽管前面也给出了一些解决方案,但还是不能够完全杜绝这种情况的发生。与此同时,在进行宏替换时,如果不使用括号完备地保护各个宏参数,那么很可能还会产生意想不到的结果。除此之外,宏还缺少必要的类型检查。而函数却从根本上避免了这些情况的产生。
4) 从代码的长度来看
在每次使用宏时,一份宏定义代码的副本都会插入程序中。除非宏非常短,否则使用宏会大幅度地增加程序的长度。而函数代码则只会出现在一个地方,以后每次调用这个函数时,调用的都是那个地方的同一份代码。
调用惯例(Calling Convention):函数的调用方和被调用方对于函数如何调用需要有一个明确的约定,只有双方都遵守同样的约定,函数才能被正确的调用。
调用惯例一般会涉及到一下三个方面:
1 函数参数传递的顺序与方式
函数传递参数的方式有很多中,可以通过寄存器、栈和内存区域传递,不过最常见的是通过栈传递。函数的调用方先将参数压入栈中,函数自己再从栈中取出参数。对于有多个参数的函数,调用惯例要规定调用方将函数压入栈的顺序:是从左到右,还是从右到左。有些惯例还允许通过寄存器传递参数,以提高性能。
2 栈的维护方式
在函数压入栈之后,函数体会被调用,此后需要将被压入栈中的参数全部弹出,以使得栈在函数调用前后保持一致。这个工作既可以由调用方来做,也可以由函数来做。
3 名字修饰
为了链接的时候对调用管理进行区分,调用管理要对函数本身的名字进行修饰。不同的调用管理有不同的名字修饰策略。
这里我们主要介绍的cdecl、stdcall、fastcall三种c中主要的调用惯例,还有pascal、naked call、thiscall调用管理。这三种调用的区别如下:
调用惯例 | 出栈方 | 参数传递 | 名字修饰 |
cdecl | 函数调用方 | 从右至左压入栈 | 下划线+函数名 |
stdcall | 函数本身 | 从右至左压入栈 | 下划线+函数名+@+参数的字节数 |
fastcall | 函数本身 | 头两个DWORD(4字节)类型或者占更少 字节的参数被放入寄存器,其它剩下的参数 按从右至左的顺序压入栈 | @+函数名+@+参数的字节数 |
下面用一个实际的例子来看看这些调用方式具体是怎么实现的:
1 #include <stdio.h> 2 3 void __attribute__ (( cdecl)) 4 a(int a, int b, int c) 5 { 6 char buffer1[5]; 7 char buffer2[10]; 8 } 9 10 int main ( int argc, char *argv[] ) 11 { 12 a(1, 2, 3); 13 return 0; 14 } /* ---------- end of function main ---------- */
编译上面的代码,然后反汇编看下main函数和a函数的汇编代码:
从反汇编的代码中可以看出main函数调用a时,参数是通过栈传输的,并且是从右至左向栈中压。a函数并没有维护栈,但是main函数貌似也没有维护栈,其实不然,main函数是用mov指令代替了push指令,所以esp的值并没有改变,也就不必维护了。不过如果用push,那就要维护esp的值,在编译时加上“-mno-accumulate-outgoing-args”选项就可以看到这种情况。这种调用惯例是gcc默认的,也就是cdecl惯例。
如果把上面代码中的第3行的cdecl换成stdcall,情况又会是怎样的呢?我们反汇编看下:
确实可以在a函数中看到它用ret指令维护了堆栈。不过对于用mov实现栈参数压入的main来说却反而要维护esp了,由于a中让esp减了0xc,所以回到main中后就必须回复esp的值,这也是为什么call a后main中将esp加了0xc。
如果把上面代码中的第3行的cdecl换成fastcall,情况又会是怎样的呢?我们反汇编看下:
从main中可以看出,调用a函数的前两个参数分别通过ecx和edx传送,最后一个参数通过栈传送。a函数也维护了栈。
pascal调用惯例是将参数从左至右传送,函数自己维护栈,函数命名比较的复杂,貌似gcc通过前面的方式设置这种惯例不行。
C++内存区域分为5个区域。分别是堆,栈,自由存储区,全局/静态存储区和常量存储区。(同理解C)
栈:由编译器在需要的时候分配,在不需要的时候自动清除的变量存储区。里面通常是局部变量,函数参数等。
堆:由new分配的内存块,他们的释放编译器不去管,由我们的应用程序去控制,一般一个new对应一个delete。如果程序员没有释放掉,那么在程序结束后,操作系统会自动回收。
自由存储区:由malloc等分配的内存块,和堆十分相似,不过它使用free来结束自己的生命。
全局/静态存储区:全局变量和静态变量被分配到同一块内存中,在以前的c语言中。全局变量又分为初始化的和未初始化的,在c++里面没有这个区分了,他们共同占用同一块内存。
常量存储区:这是一块比较特殊的存储区,里面存放的是常量,不允许修改。
C++内存区域中堆和栈的区别:
管理方式不同:栈是由编译器自动管理,无需我们手工控制;对于堆来说,释放由程序员完成,容易产生内存泄漏。
空间大小不同:一般来讲,在32为系统下面,堆内存可达到4G的空间,从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲,一般都是有一定空间大小的,例如,在vc6下面,默认的栈大小好像是1M。当然,也可以自己修改:打开工程。 project-->setting-->link,在category中选中output,然后再reserve中设定堆栈的最大值和 commit。
能否产生碎片:对于堆来讲,频繁的new/delete势必会造成内存空间的不连续,从而造成大量的碎片,使程序效率降低。对于栈来讲,则不会存在这个问题。
生长方向不同:对于堆来讲,生长方向是向上的,也就是向着内存地址增加的方向;对于栈来讲,它的生长方式是向下的,是向着内存地址减小的方向增长。
分配方式不同:堆都是动态分配的;栈有静态和动态两种分配方式。静态分配由编译器完成,比如局部变量的分配。动态分配由alloca函数进行、但栈的动态分配和堆是不同的,它的动态分配由编译器进行释放,无需我们手工实现。
分配效率不同:栈是机器系统提供的数据结构,计算机会在底层对栈提供支持:分配专门的寄存器存放栈的地址,压栈出栈都有专门的指令执行,这就决定了栈的效率比较高。堆则是c/c++库函数提供的,机制很复杂。库函数会按照一定的算法进行分配。显然,堆的效率比栈要低得多。
进程内存中的映像,主要有代码区,堆(动态存储区,new/delete的动态数据),栈,静态存储区
内存区域地址从低到高的方向:代码区,静态存储区,堆,栈
堆”和“栈”是独立的概念平常说的“堆栈”实际上是两个概念:“堆”和“栈”。在英文中,堆是heap,栈是stack,不知道什么时候,什么原因,在中文里,这两个不同的概念硬是被搞在一起了,所以,围绕这个混合词所发生的误解和争执这几年就没有断过。
“栈”一般是由硬件(CPU)实现的,CPU用栈来保存调用子程序(函数)时的返回地址,高级语言有时也用它作为局部变量的存储空间。
“堆”是个实实在在的软件概念,使用与否完全由编程者“显示地(explicitly)”决定,如malloc。
程序经过编译连接生成执行程序后,堆和栈的起始地址就已经确定了(具体说,是通过“连接程序”),在一个具有反向增长的栈的CPU上,数据空间可表示如下:
低 ->|-----------------|
| 全局量(所有已初始化量 .data, |
| 未初始化量 .bss ) |
堆起始->|-----------------|
| 堆向高地址增长 |
| |
| |
| 自由空间 |
| |
| |
| 栈向低地址增长 |
高 栈起始->|-----------------|
在内存中,“堆”和“栈”共用全部的自由空间,只不过各自的起始地址和增长方向不同,它们之间并没有一个固定的界限,如果在运行时,“堆”和 “栈”增长到发生了相互覆盖时,称为“栈堆冲突”,系统肯定垮台。由于开销方面的原因,各种编译在实现中都没有考虑解决这个问题,只有靠设计者自己解决,比如增加内存等。
=================================================================
说明(128为例)硬堆栈:
即SP,通常汇编中讲的所谓堆栈(用于PC指针等压栈),一般设置从片内RAM的顶部0X10FF开始向下生长,基本上64个足够足够了
软件堆栈:
C编译器自动分配的堆栈,在硬堆栈和全局变量之间的空间,也是向下生长,一般用于局部变量。比如一个子程序定义一个局部变量A[256],那么此空间即在软堆栈中,假设当前软堆栈用到0X800,分派A[256]后,软堆栈用到0X700,A[0]地址为0X700,A[1]地址为 0X701 ……,当然如果局部变量较少,用寄存器就可以了,用不着软堆栈了。此子程序退出后软堆栈恢复到0X800。
另:你的C程序编译后,生成的汇编文件中,R28:R29就是软堆栈指针
一般硬堆栈只要在编译选项中设置,软堆栈编译器会自动设置。你只要看看*.mp文件是否合理就可以了。
指针的步长
#include <stdio.h> #include <stddef.h> struct Person { int a; char b; char buf[64]; int d; }; int main(int argc, char **argv) { struct Person p = {10,'A',"I love China",200}; char b; int a; //获取结构体Person char b的偏移量 printf("A offset is:%d\n",offsetof(struct Person,b)); //offset is : 4 //获取int d 的值 //获取结构体p的首地址 (char *)&p+offsetof(struct Person,d) //int d 是整型 要转换成int * (int *)((char *)&p+offsetof(struct Person,d)) //取值 解引用 *(int *)((char *)&p+offsetof(struct Person,d)) printf("d's value is :%d\n",*(int *)((char *)&p+offsetof(struct Person,d))); return 0; }
指针做函数参数的输出特性
#include <stdio.h> #include <stdlib.h> #include <string.h> void changeValue(char **temp){ char *p = malloc(sizeof(char)*100); memset(p,0,100); strcpy(p,"hello world I love china"); *temp = p; } int main(int argc ,char **argv) { char *p = NULL; changeValue(&p); printf("p's value is %s\n",p); if(p != NULL) { free(p); p = NULL; } return 0; }
字符串拷贝实现
#include <stdio.h> #include <stdlib.h> #include <string.h> void test1(char *dest,char *sour){ int len = strlen(sour); for(int i=0;i<len;++i){ dest[i] = sour[i]; } dest[len] = '\0'; } void test2(char *dest, const char *sour){ while(*sour != '\0'){ *dest = *sour; sour++; dest++; } *dest = '\0'; } void test3(char *dest,char *sour){ while(*dest++ = *sour++); } int main(int argc ,char **argv) { char *s = "hello world"; char buf[1024] = {0}; test1(buf,s); printf("buf1's value is %s\n",buf);
memset(buf,0,1024); test2(buf,s); printf("buf2's value is %s\n",buf);
memset(buf,0,1024); test3(buf,s); printf("buf3's value is %s\n",buf); return 0; }
malloc,alloc,realloc之间的相似与区别
三个函数的申明分别是:
void* realloc(void* ptr, unsigned newsize);
void* malloc(unsigned size);
void* calloc(size_t numElements, size_t sizeOfElement);
都在stdlib.h函数库内。它们的返回值都是请求系统分配的地址,如果请求失败就返回NULL。
malloc与calloc的区别为1块与n块的区别:
malloc调用形式为(类型*)malloc(size):在内存的动态存储区中分配一块长度为“size”字节的连续区域,返回该区域的首地址。
calloc调用形式为(类型*)calloc(n,size):在内存的动态存储区中分配n块长度为“size”字节的连续区域,返回首地址。
realloc调用形式为(类型*)realloc(*ptr,size):将ptr内存大小增大到size。(也可以缩小,缩小的内容消失)。
另外有一点不能直接看出的区别是,malloc 只管分配内存,并不能对所得的内存进行初始化,所以得到的一片新内存中,其值将是随机的。calloc在动态分配完内存后,自动初始化该内存空间为零。
realloc有个细节需要注意:
无非就是将已经存在的一块内存扩大。
char* p = malloc(1024);
char* q = realloc(p,2048);
现在的问题是我们应该如何处理指针 p。 刚开始按照我最直观的理解,如果就是直接将 p = NULL;。 到最后只需要释放 q的空间就可以了。
因为最近在做个封装。结果在做单元测试的时候发现。有时候我在 free(q); 的时候会出错。这样我就郁闷了。
后来仔细一跟踪,发现 realloc 完以后 q 和 p 的指针地址是一样。不过有时候又不一样。
仔细查了下资料。得到如下信息:
1.如果 当前连续内存块足够 realloc 的话,只是将p所指向的空间扩大,并返回p的指针地址。 这个时候 q 和 p 指向的地址是一样的。
2.如果 当前连续内存块不够长度,再找一个足够长的地方,分配一块新的内存,q,并将 p指向的内容 copy到 q,返回 q。并将p所指向的内存空间删除。
这样也就是说 realloc 有时候会产生一个新的内存地址 有的时候不会。所以在分配完成后。我们需要判断下 p 是否等于 q。并做相应的处理。
这里有点要注意的是要避免 p = realloc(p,2048); 这种写法。有可能会造成 realloc 分配失败后,p原先所指向的内存地址丢失。
sscanf()的用法
sscanf() - 从一个字符串中读进与指定格式相符的数据.
函数原型:
int sscanf( string str, string fmt, mixed var1, mixed var2 ... );
int scanf( const char *format [,argument]... );
说明:
sscanf与scanf类似,都是用于输入的,只是后者以屏幕(stdin)为输入源,前者以固定字符串为输入源。
其中的format可以是一个或多个 {%[*] [width] [{h | l | I64 | L}]type | ' ' | '\t' | '\n' | 非%符号}
注:
1、 * 亦可用于格式中, (即 %*d 和 %*s) 加了星号 (*) 表示跳过此数据不读入. (也就是不把此数据读入参数中)
2、{a|b|c}表示a,b,c中选一,[d],表示可以有d也可以没有d。
3、width表示读取宽度。
4、{h | l | I64 | L}:参数的size,通常h表示单字节size,I表示2字节 size,L表示4字节size(double例外),l64表示8字节size。
5、type :这就很多了,就是%s,%d之类。
6、特别的:%*[width] [{h | l | I64 | L}]type 表示满足该条件的被过滤掉,不会向目标参数中写入值
支持集合操作:
%[a-z] 表示匹配a到z中任意字符,贪婪性(尽可能多的匹配)
%[aB'] 匹配a、B、'中一员,贪婪性
%[^a] 匹配非a的任意字符,贪婪性
注意:在读入的字符串是空字符串时,sscanf函数并不改变待读入到的字符串的值。
例子:
1. 常见用法。
char buf[512] = ;
sscanf("123456 ", "%s", buf);
printf("%s\n", buf);
结果为:123456
2. 取指定长度的字符串。如在下例中,取最大长度为4字节的字符串。
sscanf("123456 ", "%4s", buf);
printf("%s\n", buf);
结果为:1234
3. 取到指定字符为止的字符串。如在下例中,取遇到空格为止字符串。
sscanf("123456 abcdedf", "%[^ ]", buf);
printf("%s\n", buf);
结果为:123456
4. 取仅包含指定字符集的字符串。如在下例中,取仅包含1到9和小写字母的字符串。
sscanf("123456abcdedfBCDEF", "%[1-9a-z]", buf);
printf("%s\n", buf);
结果为:123456abcdedf
5. 取到指定字符集为止的字符串。如在下例中,取遇到大写字母为止的字符串。
sscanf("123456abcdedfBCDEF", "%[^A-Z]", buf);
printf("%s\n", buf);
结果为:123456abcdedf
6、给定一个字符串iios/12DDWDFF@122,获取 / 和 @ 之间的字符串,先将 "iios/"过滤掉,再将非'@'的一串内容送到buf中
sscanf("iios/12DDWDFF@122", "%*[^/]/%[^@]", buf);
printf("%s\n", buf);
结果为:12DDWDFF
7、给定一个字符串““hello, world”,仅保留world。(注意:“,”之后有一空格)
sscanf(“hello, world”, "%*s%s", buf);
printf("%s\n", buf);
结果为:world
%*s表示第一个匹配到的%s被过滤掉,即hello被过滤了
如果没有空格则结果为NULL。
sscanf的功能很类似于正则表达式, 但却没有正则表达式强大,所以如果对于比较复杂的字符串处理,建议使用正则表达式.
//-------------------------------------------------------
sscanf,表示从字符串中格式化输入
上面表示从str中,输入数字给x,就是32700
久以前,我以为c没有自己的split string函数,后来我发现了sscanf;一直以来,我以为sscanf只能以空格来界定字符串,现在我发现我错了。
sscanf是一个运行时函数,原形很简单:
int sscanf(
const char *buffer,
const char *format [,
argument ] ...
);
它强大的功能体现在对format的支持上。
我以前用它来分隔类似这样的字符串2006:03:18:
int a, b, c;
sscanf("2006:03:18", "%d:%d:%d", a, b, c);
以及2006:03:18 - 2006:04:18:
char sztime1[16] = "", sztime2[16] = "";
sscanf("2006:03:18 - 2006:04:18", "%s - %s", sztime1, sztime2);
但是后来,我需要处理2006:03:18-2006:04:18
仅仅是取消了‘-’两边的空格,却打破了%s对字符串的界定。
我需要重新设计一个函数来处理这样的情况?这并不复杂,但是,为了使所有的代码都有统一的风格,我需要改动很多地方,把已有的sscanf替换成我自己的分割函数。我以为我肯定需要这样做,并伴随着对sscanf的强烈不满而入睡;一觉醒来,发现其实不必。
format-type中有%[]这样的type field。如果读取的字符串,不是以空格来分隔的话,就可以使用%[]。
%[]类似于一个正则表达式。[a-z]表示读取a-z的所有字符,[^a-z]表示读取除a-z以外的所有字符。
所以那个问题也就迎刃而解了:
sscanf("2006:03:18 - 2006:04:18", "%[0-9,:] - %[0-9,:]", sztime1, sztime2);
如何定义数组指针
#include <stdio.h> #include <stdlib.h> #include <string.h> //sizeof 和 对数组名取地址 不是首地址 而是数组指针 int main(int argc ,char **argv) { int arr[5] = {1,2,3,4,5,6}; typedef int (ARRAY_TYPE)[5]; //define a new data type array_type ARRAY_TYPE narr; int i; for(i=0;i<5;i++) { narr[i] = arr[i]; } for(i= 0;i<5;i++) { printf("%d\n",narr[i]); } typedef int (*ARRAY_POINT)[5]; //保存数组的首地址 ARRAY_POINT ap; int j =0; *ap = arr; for(j=0;j<5;j++) { printf("new value %d\n",*(*ap+j)); } return 0; }
结构体深拷贝和浅拷贝
一、结构体的浅拷贝
1.结构体的浅拷贝是把一个结构体的内容拷贝到另外一个结构体,仔细看代码就可以
#include <stdlib.h> #include <string.h> #include <windows.h> typedef struct teacher { char *name; int age; }teacher; int main() { teacher t1; t1.name = (char*)malloc(30);//给name动态分配空间 strcpy(t1.name, "liming");//把文字常量区的内容拷贝给t1.name t1.age = 22; teacher t2 = t1;//结构体的浅拷贝 printf("%s %d", t2.name, t2.age); if (t1.name != NULL) //释放分配给t1.name 的堆区空间 { free(t1.name); t1.name = NULL; } //C语言中不能存在二次释放,会导致程序崩溃,画出内存图,可以看到t1.name和t2.name指向同一内存 //if (t2.name != NULL) //{ // free(t2.name); // t2.name = NULL; //} return 0; }
2.结构体的深拷贝
给t2单独分配一块空间进行拷贝,代码如下:
#include <stdio.h> #include <stdlib.h> typedef struct teacher { char *name; int age; }teacher; int main() { teacher t1; t1.name = (char*)malloc(30); strcpy(t1.name, "lily"); t1.age = 22; teacher t2; t2 = t1; t2.name = (char*)malloc(30);//给t2.name重新分配空间 strcpy(t2.name, t1.name); printf("%s %d", t2.name, t2.age); if (t1.name != NULL)//释放t1.name和t2.name的堆区空间 { free(t1.name); t1.name = NULL; } if (t2.name != NULL) { free(t2.name); t2.name = NULL; } return 0; }
使用动态内存