学习C语言的一些需要注意的点

####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。