最近收集了许多嵌软的面试题,内容都是在很多文章中剪下来的!
#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
使用#define预处理器指令需要注意的是,不能以分号结束,并且尽量不要自己计数,要懂得预处理器可以帮我们计数常数表达式的值。#define使用比较严谨,考虑到使用场合,括号一般很常用。这个表达式会使16位机的整数型溢出,UL代表unsigned long。
#define MIN(A,B) ( (A) <= (B)? (A) :(B) )
这里用到三重条件操作符,使得代码简洁。一定要注意,使用#define预处理器指令比较严谨,考虑到使用场合,括号一般很常用。
#error 指令让预处理器发出一条错误信息,并且会中断编译过程。
用法:#error “ERROR!”
用法:#pragma pack(n) /*指定按n字节对齐*/
#pragma pack() /*取消自定义字节对齐*/
用法:#pragma message(“HELLO!”)
用法:#pragma warning( disable : 4507 34 ; once : 4385 ; error:164 )
等价于#pragma warning( disable : 4507 34 ) //不显示4507和34号警告信息
#pragma warning( once : 4385 ) //4385号警告信息仅报告一次
#pragma warning( error:164 ) //把164号警告信息作为一个错
用法loop:
...
goto loop;
int main()
{int i=1,j=0;Start:i++; while(j<99) {goto start;j++;}return i;
}
在这里值得注意的是:
指向整形数表明的是:(int *) 一起用。括号可省略。
在第C项中,加上括号为:(((int *)*)a);括号可省略。
在第f项中,加上了括号,使得默认的括号失去了效果,指向的是数组。第g项类同。
static关键字在C语言中的用法主要为:
修饰局部变量、全局变量和函数。被static关键字修饰过的变量或函数都存储在静态存储区,生命周期为整个程序运行结束。普通局部变量存储于堆栈中,使用完毕会立即释放。
1)对于局部变量(在函数体内定义的静态变量),初次定义时必须初始化,且只能初始化一次(若不初始化,自动赋初值),该函数在被调用过程中维持其静态变量的值不变。在函数退出时,静态存储变量依然被保存在内存中。举个例子。
void test() //函数体
{//第一次调用时定义静态变量a且初始化一次//第二次调用时定义静态变量a且忽略初始化工作static int a = 0; printf("%d", a);a++;
}int main()
{test(); // 第一次调用,输出 a = 0test(); // 第二次调用,输出 a = 1return 0;
}
2)对于全局静态变量,仅对当前文件可见(限定作用域),其他文件不可访问。而普通的全局变量对整个工程可见,其他文件可以使用extern关键字外部声明或引入头文件的形式直接使用。
3)对于静态函数,仅对当前文件可见(限定作用域),其他文件不可访问。而普通的函数,可以在另一个文件中直接引用,甚至不需要extern来声明。
const:只读
没有使用到指针时,const int a和int const a等同,代表a是一个常整形数。
int const *a; //a是一个指向常整型数的指针,指针常量(const修饰的是*a,表示值不变,地址可变)
int * const a; //a是一个指向整型数的常指针,常量指针(const修饰的是a,表示地址不变,值可变)
int const * a const; //a是一个指向常整型数的常指针(上面两种情况兼得,表示只读,其地址以及地址中的值都不可改变)
使用时需要注意指针常量和常量指针,它们的意思是不同的,很多初学者一开始都没有去区分这个区别,实际很重要。
这里借阅了其他文章的想法。volatile英文意思为,不稳定的。volatile变量表明这变量可能会被意想不到地改变,这样,编译器就不会去假设这个变量的值了。优化器在用到这个变量时必须每次都小心地重新读取这个变量的值,而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子:
可以。比如只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
可以。尽管这并不很常见。一个例子是当一个中断服务子程序修改一个指向一个buffer的指针时。
int square(volatile int *ptr)
{return ptr *ptr;
}
这段代码的目的是用来返回指针*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;
}
第一个:a|= 0x1<<3;
第二个:a&=~0x1<<3;
需要注意的是,这两个操作在对寄存器直接进行位操作很常用,这种用法也比较固定且常用。
需要注意的是,尽量用第二条,因为在很多工程中对寄存器的定义都用到类似的结构,使得代码简洁。(int * const)代表返回一个整数型的只读指针变量,地址不变。括号前面的*号代表进行指针操作,即对指针变量赋值。
__interrupt double compute_area (double radius)
{double area = PI * radius * radius;printf(” Area = %f”, area);return area;
}
这里ISR不能传入参数和返回值,做到短而有效率。
这里借阅了其他文章的想法。在许多的处理器/编译器中,浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈,有些处理器/编译器就是不允许在ISR中做浮点运算。此外,ISR应该是短而有效率的,在ISR中做浮点运算和输出打印是不明智的。printf()经常有重入和性能上的问题。
Void foo(void)
{Unsigned int a = 6;Int b = -20;(a+b > 6)?puts(“>6”):puts(“<6”);
}
答案是>6,有符号和无符号在进行运算的时候会进行隐式类型转换,将有符号转换为无符号。
有一种说法就是,在进行不同类型的运算时,变量总是从小字节往大字节隐式类型转换。
Unsigned int zero = 8;
Unsigned int compzero = 0xFFFF;
这里借阅了其他文章的想法。对于一个int型不是16位的处理器为说,上面的代码是不正确的。应编写如下:
Unsigned int compzero =~0;
#define dPS struct s *;
Typedef struct s * tPS;
以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢?(如果有的话)为什么?
答案是:typedef更好。这里借阅了其他文章的想法。预处理的工作是替换,不做正确性检查;而typedef编译时会做类型检查,适用于结构体。
思考下面的例子:
dPS p1,p2;
tPS p3,p4;
第一个扩展为
Struct s * p1,p2;
上面的代码定义p1为一个指向结构的值,p2为一个实际的结构,这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。
void Foo_1 ( char str[100])
{cout<<"Foo_1:"<<sizeof( str )<<endl;
}char str_1[] = "abcdef";
char *p = str_1 ;
cout<<sizeof(str_1); // 7 加了一个‘\0’
cout<<sizeof(p); // 4,这里有指针,p代表地址,32位代表4字节。char *str_2 = "abcdef";
char *q = str_2 ;
cout<<sizeof(str_2); // 4
cout<<sizeof(q); // 4char str_3[] = {'a','b','c','d','e','f'};
char *l = str_3 ;
cout<<sizeof(str_3); // 6
cout<<"l:"<<sizeof(l)<<endl; // 4char *str_3 = {'a','b','c','d','e','f'}; //编译错误
char *str_3 = {'a'}; //编译错误Foo_1(str_1); // 4
Foo_1(str_2); // 4
Foo_1(str_3); // 4
void *k = malloc( 100 );
cout<<sizeof(k); // 4
附:数组做形参,则退化为指针;数组的引用做形参,则数组的大小也成为形参类型的一部分。
#pragma pack(1) //以1字节对齐
struct node_t{char A;int b;int c;
};
注:这里的偏移量指的是相对于结构体起始位置的偏移量。请用代码表达。
struct node_t node;
(unsigned long)(&node.c)-(unsigned long)(&node);
这里借阅了其他文章的想法。sizeof(node)=12,这里需要了解结构体对齐规则,有感兴趣的可以去学习一下。转化为无符号长整形进行计算(因为首地址占4个字节,且第一为符号位,若两个地址相加,无符号整形表示结果,显然无法满足。所以一般转化为长整形,这样会更安全一点。)
附:结构体对齐规则链接http://t.csdn.cn/QUZv0,这博主讲解得挺好。
这里需要了解的是,常常拿栈和堆的生长方向拿来比较:
栈是从大内存存储地址到小内存存储地址增长,而堆是从小到大。
static void stackDirection()
{static char *addr = NULL;char dummy;if ( addr == NULL) //第一次进入函数{addr = &dummy; //dummy第一次的地址赋予给addr。stackDirection(); //递归调用,让dummy两次被定义,并一先一后入栈} else //第二次进入函数{ //addr相当于第一次&dummy,&dummy为第二次的地址。 if (addr > &dummy) printf("栈:向下增长");else printf("堆:向上增长"); }
}
这里借阅了其他文章的代码并进行了简化。
版权声明:本站所有资料均为网友推荐收集整理而来,仅供学习和研究交流使用。
工作时间:8:00-18:00
客服电话
电子邮件
admin@qq.com
扫码二维码
获取最新动态