####C语言学习
1.指针数组与二维数组指针
int *p[3];//指针数组。
int (*p)[3];//定义了一个指针,指向int[3]这种数据类型,指向二维数组的指针。
int buf[3][5]; 二维数组名称,buf代表数组的首地址
int (*a)[5]; 定义一个指向int[5]类型的指针变量a;
a[0],*(a+0),*a; 0行0列元素的地址;
a+1; 第1行的首地址;
a[1],*(a+1); 第1行,0列元素地址;
a[1]+2,*(a+1)+2,&a[1][2]; 第1行,2列元素的地址;
*(a[1]+2),*(*(a+1)+2),a[1][2]; 第1行,2列元素的值;
2.函数指针
int add(int a, int b)
{
return a+b;
}
int main()
{
......
int (*p)(int, int);//定义了一个指向函数的指针,可以指向两个形参都是int,返回值也是int的函数;
p = add;//直接写函数的名字,代表函数的地址,将add这个函数的地址赋值给指针变量p;
int i = 0;
i = p(5,7);//通过指针变量间接地调用指针指向的函数
//==========================================================================
void *p(int ,char*); //函数的声明,函数名:p,返回值:void* ,参数为:int,char*
void (*p)(int ,char*);//定义了一个函数指针p,此函数返回值:void,参数为:int,char*
3.memset,memcpy,memmove
这三个函数分别实现内存设置,内存拷贝和内存移动。
使用memcpy的时候,一定要确保内存没有重叠的区域。
包含<string.h>头文件
int buf[10] = { 0 };//只能用于定义数组的时候同时初始化内容。
......
buf[10] = { 0 };//错误的语法
memset(buf,0,sizeof(buf));//第一个参数是要设置的内存地址,第二个参数是要设置的值,第三个参数是内存大小(单位:字节)。
//将一块内存初始化为0,最常用的方法。
memcpy(buf2,buf1,sizeof(buf1));//将buf1的内容拷贝到buf2。
3.main函数的参数
int main(int argc,char *argv[])
{
printf("%d\n", argc);
//argc代表程序执行的时候有几个参数,程序名称本身就是一个参数,所以argc最小值为1。
//第二个参数是一个指针数组,其中每个成员的类型是char*
//argvs是一个指针数组,argc这个参数就是告诉main函数argv有多少个成员
return 0;
}
4.register变量、静态变量
register int i = 0;//建议,如果寄存器有空闲,这个变量就放在寄存器里面使用
int *p = &i;//错误,对于一个register变量,是不能取地址操作的。
......
static int a = 0;//静态变量,只初始化一次,而且程序运行期间,静态变量一直存在。
//===========================================================
main.c
static int a = 0;//一旦全局变量定义static,意思是这个变量只在定义这个变量的文件内部有效。
//在其他文件不能用extern关键字调用。
5.内存四区
void test (int a, int b)//形参,栈区
{
printf("%d,%d\n",&a,&b);
}
int a = 0;//全局变量,静态区
int main()//函数,代码区
{
int a = 0;//局部变量,栈区
static int i = 0;//静态变量,静态区
return 0;
}
......
char array[1024 * 1024 * 10];//定义一个超大的数组一定会栈溢出
//=====================================================
//堆区
//堆和栈一样,也是在程序运行的过程中可以随时修改的内存区域,但没有栈那样先进先出的顺序。
//堆是一个大容器,它的容量要远远大于栈,但是在c语言中,堆内存空间的释放需要手动通过代码来完成。
//堆的分配和释放
int main()
{
//1.栈数组
int array[10] = { 0 };
//2.堆数组
int *p = (int*)malloc(sizeof(int) * 10);//在堆中申请大小为10个int的内存空间
//char *p1 =(char*)malloc(sizeof(char) * 10);//在堆中申请大小为10个char的内存空间
//free(p);//释放通过malloc分配的内存
//free(p1);//释放通过malloc分配的内存
//malloc和free成对使用
memset(p, 0, sizeof(int) * 10);
int i;
for (i = 0; i < 10; i++)
{
p[i] = i;
}
return 0;
}
6.关于堆栈与函数的返回值、以及误区
int *get_a()//错误,不能将一个栈变量的地址通过函数的返回值返回
{
int a = 0;
return &a;
}
int *get_a1()//可以通过函数的返回值返回一个堆地址,但是记得一定要free
{
int *p = (int *)malloc(sizeof(int));//申请了一个堆空间
return p;
}
//===================================================================
//误区
void getheap(int *p)
{
p = (int *)malloc(sizeof(int) * 10);
}//getheap执行完以后,p就消失了,导致他指向的具体的堆空间的地址编号也随之消失了
int main()
{
int *p = NULL;
getheap(p);//实参没有任何改变,以下的操作都是非法的
//p[0] = 1;
//p[1] = 2;
}
//正确的写法
void getheap(int **p)
{
*p = (int *)malloc(sizeof(int) * 10);
}
int main()
{
int *p = NULL;
getheap(&p);
p[0] = 1;
p[1] = 2;
}
//==================================================================
const char *getString()//正确的模型
{
return "hello";//常量位于静态内存中
}
int main()
{
char *p = getString();
return 0;
}
7.联合体
如果联合体中有指针成员,那么一定要使用完这个指针,并且free指针之后才能使用其他成员。
8.读写文件
fopen("文件路径","%模式%");
//"r" 以只读的方式打开文件,该文件必须存在
//"r+" 以可读写的方式打开文件,该文件必须存在
//"rb+" 读写打开一个二进制文件,允许读写数据,文件必须存在
//"rw+" 读写打开一个文本文件,允许读和写
//"w" 打开只写文件,若文件存在则文件的长度清0,即该文件的内容会消失,若文件不存在则建立该文件
//"w+" 打开可读写文件,若文件存在则文件的长度清0,即该文件的内容会消失,若文件不存在则建立该文件
//"a" 以附加的方式打开只写文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被追加到文件尾,即文件原先的内容会被保留。(EOF符保留)
//"a+" 以附加的方式打开可读写文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被追加到文件尾,即文件原先的内容会被保留。(原来的EOF符不保留)
9 . 需要注意的一些函数
//========================================
fopen
fclose
//文本文件操作函数
//按照字符读写文件
int getc ( FILE * stream );
int putc ( int character, FILE * stream );
int feof ( FILE * stream );
int fprintf ( FILE * stream, const char * format, ... );
int fscanf ( FILE * stream, const char * format, ... );
//按照行读写文件
char * fgets ( char * str, int num, FILE * stream );
int fputs ( const char * str, FILE * stream );
//========================================
//二进制文件读写函数
//fread返回值代表读取了多少记录数
//按照块读写文件
size_t fread(void* _Buffer,size_t _ElementSize,size_t _ElementCount,FILE* _Stream);
size_t fwrite(void const* _Buffer,size_t _ElementSize,size_t _ElementCount,FILE* _Stream);
static int stat(char const* const _FileName, struct stat* const _Stat);
//fseek的后返回值0代表成功,-1代表失败,但如果往后移动文件指针,超过文件大小,fseek的返回值还是0,但往前移动超过文件开始位置返回-1.
int fseek(FILE* _Stream,long _Offset,int _Origin);
long ftell(FILE* _Stream);
int fflush(FILE* _Stream);
int remove(char const* _FileName);
int rename(char const* _OldFileName,char const* _NewFileName);
//注意一点下代码的区别
while (!feof)//此函数会多读一行
{
fread(&buf, 1, sizeof(buf), p);
}
while (fread(&buf, 1, sizeof(buf), p))
####C语言提高
这几天看了王保明的C语言提高发现有点乱,整理一下。便于以后复习。深入浅出。
1.第一天 (主要讲了C语言一些基本的规律)
1)数据类型的分析
int b[40];
//b+1 &b+1结果不一样 //b &b所代表的数据类型不一样
//b代表数组首元素的地址
//&b代表整个数组的地址
2.第二天(一级指针内存模型及项目开发的重点)
//1>经典字符串拷贝函数
void copy_str(char *from, char *to)
{
//while((*to = *from)!='\0')
//{
// from++;
// to++;
//}
//while((*to++ = *from++)!='\0')
//{
// ;
//}
while(*to++ = *from++);
}
//2>项目开发中的字符串模型1:strstr-whiledowhile模型(做字符串查找)
#include<stdio.h>
int getCount_dowhile(char *mystr/*in*/,char *sub/*in*/,int *ncount)
{
int ret = 0;
char *p = mystr;//不要轻易改变形参的值
int tmpCount;
if (mystr == NULL || sub == NULL || ncount == NULL)
{
ret = -1;
printf("func getCount() err:%d.(mystr == NULL || sub == NULL || ncount == NULL) \n", ret);
return ret;
}
do
{
p = strstr(p, sub);
if (p != NULL)
{
tmpCount++;
p = p + strlen(sub);
}
else
{
break;
}
} while (*p != '\0');
*ncount = tmpCount;//间接赋值是指针存在的最大意义
return 0;
}
int getCount_while(char *mystr/*in*/, char *sub/**/, int *ncount)
{
int ret = 0;
char *p = mystr;//不要轻易改变形参的值
int tmpCount;
if (mystr == NULL || sub == NULL || ncount == NULL)
{
ret = -1;
printf("func getCount() err:%d.(mystr == NULL || sub == NULL || ncount == NULL) \n", ret);
return ret;
}
while (p = strstr(p, sub))
{
ncount++;
p = p + strlen(sub);
if (*p = '\0')
{
break;
}
}
*ncount = tmpCount;//间接赋值是指针存在的最大意义
return 0;
}
int main()
{
int ret = 0;
char *p = "abcd11111abcd2222abcdqqqq";
char sub[] = "abcd";
int count = 0;
ret = getCount(p, sub, &count);
if (ret != 0)
{
printf("func getCount() err:%d\n", ret);
}
return 0;
}
//项目开发中的字符串模型2:两头堵模型.
int trimSpaceStr2( char *p, char *buf2)
{
int ret = 0;
int ncount = 0;
int i, j;
i = 0;
j = strlen(p) -1;
while (isspace(p[i]) && p[i] != '\0')
{
i++;
}
while (isspace(p[j]) && j>0 )
{
j--;
}
ncount = j - i + 1;
//
strncpy(buf2, p+i, ncount);
buf2[ncount] = '\0';
return ret;
}
3.第三天(二级指针内存模型及项目开发的重点)
//项目开发中的字符串模型3:字符串反转1.
void inverse(char *str)
{
int length;
int *p1, *p2;
if (str == NULL)
{
return -1;
}
length = strlen(str);
p1 = str;
p2 = str + length - 1;
while (p1 < p2)
{
char c = *p1;
*p1 = *p2;
*p2 = c;
p1++;
p2--;
}
}
//项目开发中的字符串模型3:字符串反转2.
void inverse02(char *p,char *bufresult)
{
if (p == NULL || bufresult == NULL)
{
return;
}
if (*p == '\0')
{
return;
}
inverse02(p + 1, bufresult);
strncat(bufresult,p,1);
}
#####数组大小要注意的地方
char a[10] = { 0 };
printf("sizeof(a):%d \t a:%p \nsizeof(&a):%d \t &a:%p \n", sizeof(a), a, sizeof(&a), &a);
printf("a+1:%p \n&a+1:%p \n", a + 1, &a + 1);
char* b[10] = { 0 };
printf("sizeof(b):%d \t b:%p \nsizeof(&b):%d \t &b:%p \n", sizeof(b), b, sizeof(&b), &b);
printf("b+1:%p \n&b+1:%p \n", b + 1, &b + 1);
//运算结果:
sizeof(a):10 sizeof(&a):4
a:0116FE34 a+1:0116FE35
&a:0116FE34 &a+1:0116FE3E
sizeof(b):40 sizeof(&b):4
b:0116FE04 b+1:0116FE08
&b:0116FE04 &b+1:0116FE2C
总的来说,sizeof(数组名)可以直接求出数组的大小,但数组名指针所代表的步长和首元素大小相等;但对数组名取地址后的二级指针的步长是整个数组的大小,sizeof的结果是4。