【嵌入式开发】C语言 内存分配 地址 指针 数组 参数 实例解析

/*************************************************************************
    > File Name: memory.c
    > Author: octopus
    > Mail: octopus_work.163.com 
    > Created Time: Mon 10 Mar 2014 08:34:12 PM CST
 ************************************************************************/

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

int global1 = 0, global2 = 0, global3 = 0;

void function(void)
{
        int local4 = 0, local5 = 0, local6 = 0;
        static int static4 = 0, static5 = 0, static6 = 0;
        int *p2 = (int*)malloc(sizeof(int));

        printf("子函数 局部变量 : \n");
        printf("local4 : %p \n", &local4);
        printf("local5 : %p \n", &local5);
        printf("local6 : %p \n", &local6);

        printf("子函数 指针变量 : \n");
        printf("p2 : %p \n", p2);

        printf("全局变量 : \n");
        printf("global1 : %p \n", &global1);
        printf("global2 : %p \n", &global2);
        printf("global3 : %p \n", &global3);

        printf("子函数 静态变量 : \n");
        printf("static4 : %p \n", &static4);
        printf("static5 : %p \n", &static5);
        printf("static6 : %p \n", &static6);

        printf("子函数地址 : \n");
        printf("function : %p \n", function);
}

int main(int argc, char **argv)
{
        int local1 = 0, local2 = 0, local3 = 0;
        static int static1 = 0, static2 = 0, static3 = 0;
        int *p1 = (int*)malloc(sizeof(int));
        const int const1 = 0;
        char *char_p = "char";

        printf("主函数 局部变量 : \n");
        printf("local1 : %p \n", &local1);
        printf("local2 : %p \n", &local2);
        printf("local3 : %p \n", &local3);
        printf("const1 : %p \n", &const1);

        printf("主函数 指针变量 : \n");
        printf("p1 : %p \n", p1);

        printf("全局变量 : \n");
        printf("global1 : %p \n", &global1);
        printf("global2 : %p \n", &global2);
        printf("global3 : %p \n", &global3);

        printf("主函数 静态变量 : \n");
        printf("static1 : %p \n", &static1);
        printf("static2 : %p \n", &static2);
        printf("static3 : %p \n", &static3);

        printf("字符串常量 : \n");
        printf("char_p : %p \n", char_p);

        printf("主函数地址 : \n");
        printf("main : %p \n", main);


        printf("= = = = = = = = = = = = = = = \n");

        function();

        return 0;
}

[root@ip28 pointer]# gcc memory.c 
[root@ip28 pointer]# ./a.out 
主函数 局部变量 : 
local1 : 0x7fff75f5eedc 
local2 : 0x7fff75f5eed8 
local3 : 0x7fff75f5eed4 
const1 : 0x7fff75f5eed0 
主函数 指针变量 : 
p1 : 0x19bad010 
全局变量 : 
global1 : 0x600e14 
global2 : 0x600e18 
global3 : 0x600e1c 
主函数 静态变量 : 
static1 : 0x600e34 
static2 : 0x600e30 
static3 : 0x600e2c 
字符串常量 : 
char_p : 0x4009f7 
主函数地址 : 
main : 0x40065f 
= = = = = = = = = = = = = = = 
子函数 局部变量 : 
local4 : 0x7fff75f5eea4 
local5 : 0x7fff75f5eea0 
local6 : 0x7fff75f5ee9c 
子函数 指针变量 : 
p2 : 0x19bad030 
全局变量 : 
global1 : 0x600e14 
global2 : 0x600e18 
global3 : 0x600e1c 
子函数 静态变量 : 
static4 : 0x600e28 
static5 : 0x600e24 
static6 : 0x600e20 
子函数地址 : 
function : 0x400528 

/*************************************************************************
    > File Name: pointer_address.c
    > Author: octopus
    > Mail: octopus_work.163.com 
    > Created Time: Mon 10 Mar 2014 09:52:01 PM CST
 ************************************************************************/

#include<stdio.h>

int main(int argc, char ** argv)
{
        int *p, *q;
        int a = 10, b;

        //p指针指向a变量
        p = &a;

        //*p 可以代替 a 进行运算
        ++*p;

        b = *p + 5;

        //指针之间可以直接相互赋值
        q = p;

        //打印 p 和 q 指针指向的值
        printf("*p = %d \n", *p);
        printf("*q = %d \n", *q);


        return 0;
}

[root@ip28 pointer]# gcc pointer_address.c 
[root@ip28 pointer]# ./a.out 
*p = 11 
*q = 11 

/*************************************************************************
    > File Name: swap.c
    > Author: octopus
    > Mail: octopus_work.163.com 
    > Created Time: Mon 10 Mar 2014 11:07:18 PM CST
 ************************************************************************/

#include<stdio.h>

void swap_1(int a, int b)
{
        int temp;
        temp = a;
        a = b;
        b = temp;

        printf("swap_1 传值 函数 a = %d, b = %d \n", a, b);
}

void swap_2(int *a, int *b)
{
        int temp;
        temp = *a;
        *a = *b;
        *b = temp;

        printf("swap_2 传址 函数 a = %d, b = %d\n", *a, *b);
}

int main(int argc, char **argv)
{
        int a = 10, b = 5;

        printf("初始值 : a = %d, b = %d \n\n", a, b);

        swap_1(a, b);
        printf("执行 swap_1 函数, a = %d, b = %d \n\n", a, b);

        swap_2(&a, &b);
        printf("执行 swap_2 函数, a = %d, b = %d \n", a, b);


        return 0;
}

[root@ip28 pointer]# gcc swap.c 
[root@ip28 pointer]# ./a.out 
初始值 : a = 10, b = 5 

swap_1 传值 函数 a = 5, b = 10 
执行 swap_1 函数, a = 10, b = 5 

swap_2 传址 函数 a = 5, b = 10
执行 swap_2 函数, a = 5, b = 10 

/*************************************************************************
    > File Name: getint.c
    > Author: octopus
    > Mail: octopus_work.163.com 
    > Created Time: Mon 10 Mar 2014 11:40:19 PM CST
 ************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define SIZE 5

int getint(int *p)
{
	//sign 是用来控制数字的正负
	int c, sign;

	//跳过空白字符, 如果是空白字符, 就会进行下一次循环, 直到不是空白字符为止

	while(isspace(c = getc(stdin)));

	//如果输入的字符不是数字, 就将预读的数据退回到标准输入流中
	if(!isdigit(c) && c != EOF && c != '+' && c != '-')
	{
		ungetc(c, stdin);
		return 0;
	}

	/*
	 * 如果预读的是减号, 那么sign 标识就是 -1, 
	 * 如果预读的是加号, 那么sign 标识就是 1;
	 */
	sign = (c == '-') ? -1 : 1;
	//如果 c 是 加号 或者 减号, 再预读一个字符&
	if(c == '+' || c == '-')
		c = getc(stdin);

	for(*p = 0; isdigit(c); c = getc(stdin))
		*p = 10 * *p + (c - '0');

	*p *= sign;

	if(c != EOF)
		ungetc(c, stdin);

	return c;
	
}

int main(int argc, char **argv)
{
	int n, array[SIZE], i; 
	for(n = 0; n < SIZE && getint(&array[n]) != EOF; n++);

	for(i = 0; i < SIZE; i++)
	{
		printf("array[%d] = %d \n", i, array[i]);
	}
	return 0;
}

octopus@octopus-Vostro-270s:~/code/c/pointer$ ./a.out 
123
123 43
674 1
array[0] = 123 
array[1] = 123 
array[2] = 43 
array[3] = 674 
array[4] = 1 

/*************************************************************************
    > File Name: array_param.c
    > Author: octopus
    > Mail: octopus_work.163.com 
    > Created Time: Sat 15 Mar 2014 12:46:57 AM CST
 ************************************************************************/

#include<stdio.h>

//计算字符串长度
int strlen(char *s)
{
        int n;
        for(n = 0; *s != '\0'; s++)
                n++;
        return n;
}

int main(int argc, char** argv)
{
        printf("strlen(djdhaj) = %d \n", strlen("djdhaj"));
        printf("strlen(12) = %d \n", strlen("12"));
        printf("strlen(dfe) = %d \n", strlen("dfe"));
}

[root@ip28 pointer]# gcc array_param.c 
array_param.c:12: warning: conflicting types for built-in function ‘strlen’
[root@ip28 pointer]# ./a.out           
strlen(djdhaj) = 6 
strlen(12) = 2 
strlen(dfe) = 3 

/*************************************************************************
    > File Name: param_array_pointer.c
    > Author: octopus
    > Mail: octopus_work.163.com 
    > Created Time: Sat 15 Mar 2014 01:28:33 AM CST
 ************************************************************************/

#include<stdio.h>

//使用指针做形参 取指针的前两位 和 当前位
void fun_p(int *p)
{
        printf("*(p - 2) = %d \n", *(p - 2));
        printf("*p = %d \n", *p);
}

//使用数组做形参 取数组的 第-2个元素 和 第0个元素
void fun_a(int p[])
{
        printf("p[-2] = %d \n", p[-2]);
        printf("p[0] = %d \n", p[0]);
}

int main(int argc, char **argv)
{
        int array[] = {1,2,3,4,5};
        //向指针参数函数中传入指针
        printf("fun_p(array + 2) : \n");
        fun_p(array + 2);

        //向数组参数函数中传入数组元素地址
        printf("fun_a(&array[2]) : \n");
        fun_a(&array[2]);

        //向指针参数函数中传入数组元素地址
        printf("fun_p(&array[2]) : \n");
        fun_p(&array[2]);

        //向数组参数函数中传入指针
        printf("fun_a(array + 2) : \n");
        fun_a(array + 2);
        return 0;
}

[root@ip28 pointer]# gcc param_array_pointer.c 
[root@ip28 pointer]# ./a.out 
fun_p(array + 2) : 
*(p - 2) = 1 
*p = 3 
fun_a(&array[2]) : 
p[-2] = 1 
p[0] = 3 
fun_p(&array[2]) : 
*(p - 2) = 1 
*p = 3 
fun_a(array + 2) : 
p[-2] = 1 
p[0] = 3