嵌入式中C语言比较经典的题目的梳理，看后绝对能区分是纯软件还是和硬件打交道的

精华

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

#define SECOND_PER_YEAR (60 * 60 * 24 * 365)*1UL
#define SECOND_PER_YEAR_2 (unsigned long)((60) * (60) * (24) * (365))
#define MIN(A,B) ((A) <= (B) ? (A) : (B))

#define BIT3 (0x1 << 3)

//用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）

void test01()
{
    // unsigned long temp = SECOND_PER_YEAR;
    printf("SECOND_PER_YEAR = %lu\n",SECOND_PER_YEAR);
    printf("SECOND_PER_YEAR_2 = %lu\n",SECOND_PER_YEAR_2);
    return ;
}


//写一个"标准"宏MIN ，这个宏输入两个参数并返回较小的一个

void test02(int * a, int * b)
{
    printf("MIN(a,b) = %d\n",MIN(*a,*b));
    return ;
}

#if 0
//预处理器标识#error的目的是什么？
//用于在编译阶段抛出错误信息，适合检查程序员在预处理阶段的限制不一致或者违规行为。

#if  defined(DEBUG) && define(NO_DEBUG)  
#error DEBUG and NO_DEBUG all defined!  
#endif

#endif


//用变量给出下面的定义

void test03()
{
        int temp = 0;
        //a) 一个整型数（An integer） 
        int a = 0;

        //b)一个指向整型数的指针（ A pointer to an integer） 
        int * b = &temp;

        //c)一个指向指针的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）
        int * p = NULL;
        int **c  = &p;

        //d)一个有10个整型数的数组（ An array of 10 integers） 
        int d[10] = {0};

        //e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to integers）
        int * e[10] = {NULL};

        //f) 一个指向有10个整型数数组的指针（ A pointer to an array of 10 integers） 
        int temp_e[10] = {0};
        int *f = temp_e;
        //int (*a)[10];

        //g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer） 
        int (*g)(int);

        //h)一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）
        int (*h[10])(int);

        return ;

}

#if 0
关键字static的作用是什么？

在C语言中，关键字static有三个明显的作用：

 （1）在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
 （2）在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
 （3）在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

#endif

#if 0


//关键字volatile有什么含意?并给出三个不同的例子。
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
 并行设备的硬件寄存器（如：状态寄存器）
 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
 多线程应用中被几个任务共享的变量

 一个参数既可以是const还可以是volatile吗？解释为什么。
 一个指针可以是volatile 吗？解释为什么。
 下面的函数有什么错误：
int square(volatile int *ptr)
{
	return *ptr * *ptr;
}

是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
这段代码有点变态。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

int square(volatile int *ptr) 
{
	int a,b;
	a = *ptr;
	b = *ptr;
	return a * b;
}

由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

long square(volatile int *ptr) 
{
	int a;
	a = *ptr;
	return a * a;
}

#endif


#if 0 

位操作（Bit manipulation） 

// 给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。

用 #defines 和 bit masks 操作。这是一个有极高可移植性的方法，是应该被用到的方法。

#define BIT3 (0x1 << 3)
static int a;

void set_bit3(void)
{
	a |= BIT3;
}

void clear_bit3(void)
{
	a &= ~BIT3;
}

#endif

// 给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。
void test04()
{
    unsigned int a = 0x00;
    a |= BIT3;
    printf("a = %d\n",a);

    unsigned int b = 0x08;
    b &= ~BIT3;
    printf("b = %d\n",b);

}

//嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，设置一绝对地址为0xcc2467a9的整型变量的值为0xaa66。
#if 0

访问固定的内存位置（Accessing fixed memory locations） 

#endif 

void test05()
{
    int * p = (int *)0xcc2467a9;//野指针
    *p = 0xaa66;
    *(int *const)0xcc2467a9  = 0xaa66;
    printf("*p = %u\n",*p);
    return ;    
}

#if 0

中断（Interrupt） 

中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展—让标准C支持中断。具代表事实是，产生了一个新的关键字__interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR)。

__interrupt double compute_area (double radius) 
{
	double area = PI * radius * radius;
	printf("\nArea = %f", area);
	return area;
}

（1）不能返回一个值。因为它的生命周期只是在函数体内，离开该函数体，这个变量将是一个垃圾值。

（2）ISR 不能传递参数。

（3）在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，有些处理器/编译器就是不允许在ISR中做浮点运算。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的。

（4）intf()经常有重入和性能上的问题。


#endif

# if 0

//下面的代码输出是什么，为什么？

void foo(void)

{
	unsigned int a = 6;
	int b = -20;
	(a+b > 6) ? puts("> 6") : puts("<= 6");
}
当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。 因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。

#endif

 void test06()
 {
    unsigned int a = 6;
	int b = -20;
	int ret = (a+b > 6) ? puts("> 6") : puts("<= 6");
    // printf("ret = %d\n",ret);
    
 }


# if 0

动态内存分配（Dynamic memory allocation） 
//尽管不像非嵌入式计算机那么常见，嵌入式系统还是有从堆（heap）中动态分配内存的过程的。那么嵌入式系统中，动态分配内存可能发生的问题是什么？

下面的代码片段的输出是什么，为什么？

char *ptr;
if ((ptr = (char *)malloc(0)) == NULL) 
{
	puts("Got a null pointer");
}

else
{
	puts("Got a valid pointer");
}

#endif
void test07()
{
    char *ptr;
    if ((ptr = (char *)malloc(0)) == NULL) 
    {
        puts("Got a null pointer");
    }

    else
    {
        puts("Got a valid pointer");
    }  
}

#if 0

typedef
 
//typedef 在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。

#define dPS struct s *
typedef struct s * tPS;

以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？
这是一个非常微妙的问题，任何人答对这个问题（正当的原因）是应当被恭喜的。答案是：typedef更好。

dPS p1,p2;
tPS p3,p4;

第一个扩展为

struct s * p1, p2;

上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。

#endif

int main(int argc, char const *argv[])
{
    int a,b;

    a = 10;
    b = 20;

    test01();
    test02(&a,&b);
    test03();
    test04();
    //test05();
    test06();
    test07();



    return 0;
}

测试结果

好好去看一遍，思考一下，会对C有了一个新的认识，也会对硬件上C的使用有一个意识！