9.1 作用域 static extern malloc relloc

最新推荐文章于 2018-05-09 15:44:25 发布

转载最新推荐文章于 2018-05-09 15:44:25 发布 · 107 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

原文链接：http://www.cnblogs.com/l6241425/p/3955052.html

本文深入探讨了C语言中的高级技巧，包括变量作用域、指针应用、内存管理等核心概念，以及如何避免常见错误。

windows里命令行参数

只有可执行程序的时候，可以把文件拖拽到可执行程序上面

相当于把文件名当参数传递了

变量作用域：

#include <stdio.h>
#include <string.h>
int main()
{
int i = 10;
while( i-- ) //这个i是上面的i,所以只会输出10次
{
int i = 0; //去掉这一句，结果会变成一个死循环，会无限输出9
printf("i = %d\n" , i++);
}
return 0;
}

指针指向一个局部的变量：

#include <stdio.h>
#include <string.h>
int main()
{
int *p = NULL;
{
int i = 100;
p = &i;
}
*p = 10;
printf("*p = %d\n" , *p);
return 0;
}

结果是正确的，但是极其不建议这样使用

register寄存器变量不能取其地址

#include <stdio.h>
#include <string.h>
int main()
{
//int i = 10;
register int i = 10;
printf("%p\n",&i); //编译就不通过
return 0;
}

static 静态变量：

static虽然在块作用域内，但在程序刚加载的时候就存在了，并且只初始化了一次，在内存中位于静态区。

不过块作用域外面还是无法访问到

int main()
{
while( i-- )
{
static int i = 0;
}
return 0;
}

两个不同文件之间， static用来限制变量只在当前文件有效：

a.c

int a = 5;
int main()
{
printf("%d\n" , a);
return 0;
}

b.c

int a = 10;

编译报错， `a'被多次定义

解决方法在a.c文件里 int前面加个static

访问的就是当前这个文件的a,即输出5

如果两个文件都有static,说明两个文件内都有a这个变量

a.c

#include <stdio.h>
static int a = 5;
int main()
{
printf("%d\n" , a);
return 0;
}

b.c

static int a = 10;

结果也是5

两个不同文件之间， extern引用同一个变量：

a.c

#include <stdio.h>
int main()
{
printf("%d\n" , a);
return 0;
}

b.c

int a = 10;

编译报错，找不到a

解决方法在a.c里全局变量里加入int a 或者 extern int a 或者 extern a 只进行一个声明

#include <stdio.h>
extern int a;
int main()
{
printf("%d\n" , a);
return 0;
}

或者在 a.c 局部变量里 extern int a 或者 extern a 注意这里直接int a 不行，就相当于定义了一个未初始化的局部变量;

#include <stdio.h>
int main()
{
extern int a;
printf("%d\n" , a);
return 0;
}

两个不同文件之间函数声明引用同一个函数：

下面可以正确执行，但是建议在a.c里声明一下 func ,就是函数的原型

a.c

#include <stdio.h>
void func(); //省略一样正确执行
int main()
{
func();
return 0;
}

b.c

#include <stdio.h>
void func()
{
printf("func\n");
}

如果在b.c文件里的func函数前面加个static，那么就会访问不到这个函数

因此可以得出结论

不同文件之间使用同一个函数需要函数声明

不同文件之间使用同一个变量需要extern

全局变量和静态变量：

注意，全局变量和静态变量，不初始化的时候，系统会自动初始化为0

#include <stdio.h>
int a;
int main()
{
printf("%d\n" , a);
return 0;
}

内存栈区是从高地址到低地址，和堆顺序相反

#include <stdio.h>
void test(int a , int b)
{ //注意，参数是在这个位置才开始入栈，不是在main函数调用时入的
printf("%p , %p\n" , &a , &b); //注意，函数形参也是在栈区，形参是从右到左入栈，所以右面的参数地址高于左边的参数地址
}
int main()
{
int a = 10 ;
int b = 20;
printf("%p , %p\n" , &a , &b);
test( a , b);
return 0;
}

free一个函数返回的指针,因为地址一样：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *test()
{
char *s = malloc(sizeof(char) * 10);
printf("s = %p\n" , s);
strcpy( s , "hello");
return s;
}
int main()
{
char *p = test();
printf("%s\n",p);
printf("p = %p\n" , p);
free(p); //这种情况完全是可以free的，因为返回的地址和你要释放的地址是一个地方
return 0;
}

函数参数指针的类型，严重错误，加强理解

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void test( char * p)
{
p = malloc(sizeof(char) * 10);
strcpy( p , "hello");
printf("%p\n",p);
}
int main()
{
char *s = NULL;
test(s);
printf("%p\n",s);
printf("%s\n" , s);
return 0;
}

这个严重新手级的错误，你传递的指针只是传递的当前的NULL，新开辟的内存返回地址，你不知道

解决方案有三种：

第一种解决方案是把传递指针的地址上策

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void test( char ** p)
{
*p = malloc(sizeof(char) * 10);
strcpy( *p , "hello");
printf("%p\n",*p);
}
int main()
{
char *s = NULL;
test(&s);
printf("%p\n",s);
printf("%s\n" , s);
free(s);
return 0;
}

第二种解决方案是把指针返回。中策

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char * test( char * p)
{
p = malloc(sizeof(char) * 10);
strcpy( p , "hello");
printf("%p\n",p);
return p;
}
int main()
{
char *s = NULL;
s = test(s);
printf("%p\n",s);
printf("%s\n" , s);
free( s );
return 0;
}

第三种解决方案是在main函数里开辟下策

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void test( char * p)
{
strcpy( p , "hello");
printf("%p\n",p);
}
int main()
{
char *s = NULL;
s = malloc(sizeof(char) * 10);
test(s);
printf("%p\n",s);
printf("%s\n" , s);
free(s);
return 0;
}

malloc的应用：

#include <stdio.h>
#include <string.h>
int main()
{
int *p = malloc(sizeof(int) * 5);
memset(p, 0, sizeof(p)); //注意这里只把4个字节的内存清零了
}

sizeof(p) p是个纯指针，不是数组名，两者 sizeof有区别

解决方法：

memset ( p , 0 , sizeof ( int ) * 5 );

realloc的应用：动态添加字符串

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void init_str( char **p )
{
*p = malloc( sizeof(char) * 10 );
memset( *p , 0 ,sizeof(char) * 10 );
strcpy( *p , "hello" );
}
char* append_str( char *p , const char * s)
{
p = realloc( p , strlen(p) + strlen(s) + 1);
memset( p+strlen(p) , 0 , strlen(s)+1); //这是把申请的新内存清零
strcat(p,s);
return p;
}
int main()
{
char *s = NULL;
init_str( &s );
s = append_str( s , " world");
printf("%s\n" , s);
return 0;
}

先malloc得到一块新的内存地址，都是垃圾值

init_str 初始化先把所有内存清零

然后strcpy hello

realloc 申请内存，不过新申请的内存还是垃圾值。

通过memset把realloc申请的新内存清零

通过strcat 连接两个字符串

realloc新增加的的不会清0，需要自己清理

解决方法：

memset ( p + strlen ( p ) , 0 , strlen ( s )+ 1 );

realloc缩小内存：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
char *p = malloc(sizeof(char) * 20);
memset(p, 0, 20);
strcpy(p , "123456789");
p = realloc(p , 5);
printf("%s\n",p);
}

可以得出realloc缩小内存的情况，原来的值都会变成垃圾值。如果需要输出正常，要在最后修改成\0

realloc的其他用法：

char *p = realloc ( NULL , 5 ); 等于 char *p = malloc( 5 );

来自为知笔记(Wiz)

转载于:https://www.cnblogs.com/l6241425/p/3955052.html