C语言sizeof与字符串处理与动态内存分配及main函数参数详解

目录

• 常用的字符串处理函数(标准库里面的)
• sizeof 求字节运算符
• 动态内存分配函数
• main的参数问题

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

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

                      #include
                     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 
               int atoi(const char *nptr);
               long atol(const char *nptr);
               long long atoll(const char *nptr); 

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

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

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

                    #include
                     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 
				   int strcmp(const char *s1, const char *s2);
				   int strncmp(const char *s1, const char *s2, size_t n);

strcat / strncat 字符串连接函数

             #include
            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
        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)
			{
			}

到此这篇关于C语言sizeof与字符串处理与动态内存分配及main函数参数详解的文章就介绍到这了,更多相关C语言sizeof内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！