C语言字符串处理函数、sizeof、动态内存分配函数、main函数参数问题

常用的字符串处理函数(标准库里面的)

strlen : 用来求一个字符串的长度

					  #include <string.h>
					 size_t strlen(const char *s);
				@s : 指向要计算的那个字符串的首地址 
					“const char *” ： 表示在函数调用过程中，防止对s指向的空间里面内容进行修改。
					“size_t”: size_t => unsigned int  
							  typede unsigned int size_t  ; 

返回值: 返回字符串s第一个\0前面的字符的个数。

atoi：将十进制的数字字符串，转成整数值

 				#include <stdlib.h>
			   int atoi(const char *nptr);
			   long atol(const char *nptr);
			   long long atoll(const char *nptr); 

strcpy/strncpy ：字符串拷贝函数 将一个字符串拷贝到另外一个字符串上面去。

				 #include <string.h>
				strcpy ：用来把src指向的字符串，拷贝到dest指向的空间中去，直到遇到\0才会结束。
			   char *strcpy(char *dest, const char *src);
				@dest :  destination 目的地 ，必须是一个可写的空间
				@src : source 源，从哪里  
				返回值: 返回拷贝后目的地字符串的首地址 

strncpy : 正是为了解决strcpy的这个bug的(strcpy没有考虑到dest指向的空间的大小问题)

					#include <string.h>
					 char *strncpy(char *dest, const char *src, size_t n);
					strncpy: 把src指向的字符串前面顶多n个字符拷贝到dest指向的内存空间中去。
						它到底拷贝了多少个字符呢? 
							<= n 

						(1) 遇到\0拷贝结束，此时\0也会被拷贝。
							char s[10]; 
							strncpy(s, "12345", 10); 
							
						(2) 已经拷贝了n个字符，此时后面的字符就不会被拷贝。 
							char s[10]; 
							strncpy(s, "0123456789", 10); 

strcmp / strncmp ：一个一个字符进行比较它们对应的ASCII码

				if c1 > c2 
					返回1 
				if c1 < c2 
					返回-1 
				if c1 == c2 
					则继续比较下一个字符，如果全部相等则返回0 

				   #include <string.h>

				   int strcmp(const char *s1, const char *s2);

				   int strncmp(const char *s1, const char *s2, size_t n);

strcat / strncat 字符串连接函数

			 #include <string.h>
			strcat ： 用来把src指向的字符串拷贝到dest指向的字符串的末尾(尾部连接)
			 char *strcat(char *dest, const char *src);
			@dest ： 指向目标字符串(一段可写的空间) 
					
				@src : 指向原始字符串 
				返回值:  
					返回连接后的字符串的首地址(dest指向的首字符地址)

		 char *strncat(char *dest, const char *src, size_t n);
			strncat : 把src指向的字符串拷贝到dest末尾，但是它顶多拷贝了n个字符。
				(1) 遇到\0拷贝结束，此时\0也会被拷贝。 
				(2) 即使没有遇到\0,但是已经拷贝了n个字符啦。 

sizeof 求字节运算符

sizeof(x) : 用来求一个对象或类型所占字节数的运算符，x可以是一个对象(变量、指针、数组、==)，也可以是一个类型。

先求x的类型，然后再求该类型所占的字节数
=> typeof(x)
=> sizeof( typeof(x) )

sizeof(指针类型) == 机器字长
32bits的机器 指针所占字节数为4
64bits的机器 指针所占字节数为8

求数组的大小

		int a[100];
		sieof(a[0]) == 4 
		sizeof(a[1024]) ==  4  
		sizeof(a) == 
			typeof(a) => int[100]
			sizeof(int[100]) => 4 * 100 

		char *  p[4]; //指针数组
		sizeof(p[0]) ==  8 
		sizeof(p) == 
			typeof(p) => char* [4] 
			sizeof(char *) * 4 == 8 * 4 

		char (*p)[4];//数组指针
		sizeof(p)  ==  8 

	int (*p)(int ,int); //函数指针
		sizeof(p) ==  8 

动态内存分配函数

malloc : 用来动态分配一个size大小的内存空间，并且把分配到内存空间的首地址返回。
malloc分配的空间的生存期，是随进程持续性。
malloc分配的空间一旦分配给你，他就不会自动去释放，一定需要你调用free或你的这个进行消亡了!

		#include <stdlib.h>
		void *malloc(size_t size);
				@size : 要分配的空间的大小(以字节为单位)
				返回值:  
					成功返回分配的空间的首地址
					失败返回NULL. 
		
		char * p = (char *)malloc(100); 

free : 用来释放ptr指向的内存空间的
ptr指向的内存空间，必须是malloc/realloc/calloc这三个函数分配的内存空间。

				void free(void *ptr);
				@ptr : 指向咱们需要释放的那一块内存的首地址
					一般为malloc/realloc/calloc这三个函数的
					返回值。 

calloc : 它的作用类似于 malloc ,不过它是数组分配函数， 它分配一个数组空间，它带有两个参数。

			 void *calloc(size_t nmemb, size_t size);
				@nmemb :  表示分配多少元素 
				@size :  表示每一个元素占多少字节
				返回值: 
					成功返回分配的空间的首地址。
					失败返回NULL。

int * a = calloc(10, sizeof(int)); 

realloc : 用来把ptr(必须是malloc/realloc/calloc这三个函数分配的内存空间)指向的动态内存，扩展到size大小。

				void *realloc(void *ptr, size_t size);
				@ptr : 指向咱们需要扩展的那一块内存的首地址。
					一般为malloc/realloc/calloc这三个函数的返回值。
				@size : 扩展到size大小
				返回值: 
					成功返回分配的空间的首地址
					失败返回NULL。

				1. size > 原来的大小 
					realloc用来把ptr指向的内存，扩展到size字节，
					原来前面的内存保持不变，后面新增内存内容不会
					被初始化。
					(1) 原址扩建
					(2) 整体搬迁 
					
					2. size ==  0 
					 realloc(ptr, 0) <=> free(ptr)

main的参数问题

在linux下面，程序运行的时候，可以带参数，只不过所有的参数都当作是字符串来处理的。

			//argc ：保存你给main传参的个数
			//argv : 用来保存传递给main的所有参数的
			//int main(int argc, char * argv[])
			
			int main(int argc, char ** argv)
			{
			}