码迷,mamicode.com
首页 > 其他好文 > 详细

C 提高1 内存四区 变量本质 栈开口方向 指针铁律1

时间:2016-06-14 16:20:54      阅读:362      评论:0      收藏:0      [点我收藏+]

标签:内存   提高   四区   


C 提高第一天复习

内存四区,变量常量的本质,函数调用模型,栈开口方向,指针铁律1,指针是一种数据类型




C 提高学员标准:写一个标准的冒泡排序

选择法或者冒泡法排序

在一个函数内排序

通过函数调用的方式排序

数组做函数参数的技术盲点和推演 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
	int i = 0;
	int j = 0;
	int tmp = 0;
	int a[] = {3,66,54,32,11,22,99,2334,32};
	
	for (i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		printf("%d ",a[i]);
	}
	printf("\n", a[i]);

	for (i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		for (j = i+1; j < sizeof(a) / sizeof(int); j++)
		{
			if (a[i] > a[j])
			{
				tmp = a[i];
				a[i] = a[j];
				a[j] = tmp;
			}
		}
	}

	for (i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n", a[i]);



	system("pause");
}

编译运行:
3 66 54 32 11 22 99 2334 32
3 11 22 32 32 54 66 99 2334
请按任意键继续. . .


冒泡程序,优化输出与排序 与 函数的数组参数问题

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void printfArray(int array[], int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n", array[i]);
}

//数组做函数的参数的退回问题,退回为一个指针
//结论:把数组内存的首地址和有效长度传给被调用的函数
//本质:函数中的数组形参,编译器会把它当成指针处理
void sortArray(int array[], int len)
{
	int i, j, tmp;
	for (i = 0; i <len; i++)
	{
		for (j = i + 1; j < len; j++)
		{
			if (array[i] > array[j])
			{
				tmp = array[i];
				array[i] = array[j];
				array[j] = tmp;
			}
		}
	}
}


int main()
{

	int a[] = {3,66,54,32,11,22,99,2334,32};
	int len = sizeof(a) / sizeof(int);

	printfArray(a, len);
	sortArray(a,len);
	printfArray(a, len);
	
	system("pause");
}



编译运行:
3 66 54 32 11 22 99 2334 32
3 11 22 32 32 54 66 99 2334
请按任意键继续. . .



数据类型概念:

“类型”是对数据的抽象 

类型相同的数据有相同的表示形式、存储格式以及相关的操作 

程序中使用的所有数据都必定属于某一种数据类型 

技术分享




基本数据类型:typedef 数组与地址

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


struct teacher1{
	char name[64];
	int age;
}Teacher1;

//使用typedef,以后定义就是这样了 Teacher2 t2;
typedef struct teacher2{
	char name[64];
	int age;
}Teacher2;


int main()
{
	
	int b[10];
	printf("b:%d , b+1:%d \n", b, b + 1);
	printf("&b:%d, &b+1:%d \n", &b, &b + 1);
	// b 代表数组首元素的地址
	// &b代表整个数组的地址
	// &b+1代表跨过整个数组地址


	struct teacher1 t1;
	Teacher1.age = 0;
	Teacher2 t2;

	typedef int u32;
	printf("u32 =%d \n",sizeof(u32));


	system("pause");
}
编译运行:
b:3603504 , b+1:3603508
&b:3603504, &b+1:3603544
u32 =4
请按任意键继续. . .



数据类型的本质思考

思考数据类型和内存有关系吗?

C/C++为什么会引入数据类型?


数据类型的本质 

数据类型可理解为创建变量的模具(模子);是固定内存大小的别名。

数据类型的作用:编译器预算对象(变量)分配的内存空间大小

程序举例,如何求数据类型的大小  sizeof(int *)

请问:数据类型可以有别名吗?数据类型可以自定义吗?(typedef)

技术分享




数据类型大小C程序:

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int a = 10;
	int b[10] ;
	printf("int a:%d \n", sizeof(a));
	printf("int a:%d \n", sizeof(int *));
	printf("int b:%d \n", sizeof(b));
	printf("int b:%d \n", sizeof(b[0]));
	printf("int b:%d \n", sizeof(*b));
	printf("hello.....\n");
	return 0;
} 
编译运行:
C:\Users\chunli>gcc main.c & a
int a:4
int a:4
int b:40
int b:4
int b:4
hello.....



常量的探讨:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


char * getstr1()
{
	char *p = "1234";
	return p;
}

char * getstr2()
{
	char *p = "5678";
	return p;
}

int main()
{
	char *p1 = NULL;
	char *p2 = NULL;
	p1 = getstr1();
	p2 = getstr2();
	printf("%s,%s \n", p1, p2);
	printf("%d,%d \n", p1, p2);
	system("pause");
}

编译运行:
1234,5678
14309464,14309644
请按任意键继续. . .


改一改:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


char * getstr1()
{
	char *p = "1234";
	return p;
}

char * getstr2()
{
	char *p = "1234";
	return p;
}

int main()
{
	char *p1 = NULL;
	char *p2 = NULL;
	p1 = getstr1();
	p2 = getstr2();
	printf("%s,%s \n", p1, p2);
	printf("%d,%d \n", p1, p2);
	system("pause");
}

编译运行:
1234,1234
2054232,2054232
请按任意键继续. .



堆栈变量,函数返回一个被析构的内存空间块

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//堆
char * getmem(int size)
{
	char *p = NULL;
	p = (char *)malloc(size);
	return p;
}

//栈
//return 不是把内存块返回出来,而是把首地址返回了
char * getmem2()
{
	char p[20];
	strcpy(p, "haha2 \n");
	return p;	//【危险!】p即将释放,但是地址返回去来了。
}


int main()
{
	char  *p = NULL;
	p = getmem(20);
	strcpy(p, "haha1 \n");
	printf("%s",p);
	free(p);
	p = NULL;
	
	p = getmem2();//返回了一个被析构的数据块
	printf("%s", p);//不应该这么做!


	system("pause");
}

编译运行:
haha1
haha2
请按任意键继续. . .




栈的开口方向:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


int main()
{

	int a;
	int b;
	printf("&a = %d \n", &a);
	printf("&b = %d \n", &b);
	system("pause");
}
编译运行:
C:\Users\chunli>gcc -o main.exe main.c & main
&a = 2686652
&b = 2686648
请按任意键继续. . .

技术分享

数组基地址永远都是在下面:

技术分享



指针铁律1:指针是一种数据类型


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//*p 在等号的左边 修改内存
//*p 在等号的右边 读取内存


char * getstr()
{
	int *tmp = "hello \n";//	常量区
	return tmp;
}

int main()
{

	int a;
	char *p1 = 100;//分配4个字节
	p1 = &a;
	*p1 = 20;	//*就像一把钥匙,找到这个地址,并修改它
	printf("%d  \n", sizeof(p1));
	printf("%d  \n", *p1);

	int b = 0;
	b = *p1;
	printf("%d  \n", b);


	char p2 = (char *)malloc(100);
	char p3 = (char *)malloc(100);

	char *p4 = getstr();
//	*(p4 + 2) = ‘K‘;  因为返回的是常量	,不能修改
	printf("%s",p4);
	system("pause");
}



指针经典话语:

1,指针指向谁,就把谁的地址赋给指针;

2,指针变量 和 它指向的内存空间变量是两个不同的概念

3,理解指针的关键是内存,没有内存哪里来的指针


变量的本质是一个固定大小的数据块,变量名就是数据块的编号


内存的使用范围:

main函数可以在栈分配内存/堆分配内存/全局分配内存,可以给子函数使用

子函数在栈分配的内存不能给主函数使用,但是堆内存与全局变量是可以给main使用


编译器会为每个程序分配一个内存4区,主函数与子函数公用这个内存4区


建立正确程序运行内存布局图是学好C的关键!


 


指针铁律1:指针是一种数据类型

1)指针也是一种变量,占有内存空间,用来保存内存地址

2)*p 操作内存;

3)*就像一把钥匙,通过一个地址(&a),去修改a变量的标示的内存空间

4)不断的给指针赋值,相当于不停的改变指针的指向。

5) 指针是一种数据类型,是指它指向内存空间的数据类型





本文出自 “魂斗罗” 博客,请务必保留此出处http://990487026.blog.51cto.com/10133282/1789043

C 提高1 内存四区 变量本质 栈开口方向 指针铁律1

标签:内存   提高   四区   

原文地址:http://990487026.blog.51cto.com/10133282/1789043

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!