写出Bool、int、指针变量、float与“零值”比较的if语句Bool型： if(flag)、if(!flag)int型： if(flag == 0)、if( flag!= 0)指针变量： if(p == NULL)、if( p!= NULL)float型： const float EPSINON = 0.0001;if( (x >= -EPSINON) && (x <= EPSINON));设置地址未为0x67a9的整型变量的值为0xaa66int *prt;
ptr = (int *)0x67a9;
*ptr = 0xaa66;
*(int *)0x67a9 = 0xaa66;要对绝对地址赋值，我们可以用(unsigned int*)0x10000=1234，那么要想程序跳转到绝对地址是0x10000去执行，应该怎么做？先强制转换成函数指针：(void(*)())0x10000;再调用它：*( ( void(*)( ) )0x10000 )();描述一下gcc的编译过程gcc编译过程分为4个阶段：预处理、编译、汇编、链接预处理：进行头文件、宏定义的替换，条件编译，删除注释，还有语义和词义的分析编译：将预处理后的文件编译成汇编文件汇编：将汇编文件转换二进制文件链接：将二进制文件链接成可执行文件何时需要预编译？总是使用不经常改动的大型代码体。#include< >和#include" "的区别#include< >是到系统指定目录下寻找文件；#include" "是先到用户指定的目录下寻找文件，找不到就到系统指定目录下寻找。头文件中的ifndef/define/endif 干什么用防止头文件被重复引用。有符号与无符号的区别有符号的数据，最高位为符号位，0表示正数，1表示负数；无符号的数据，最高位不是符号位，只是数据的一部分。sizeof与strlen的区别sizeof是操作符，参数可以是数据类型，也可以是变量，在编译时就已经计算出来sizeof的结果，计算的是数据类型占内存的大小；strlen是库函数，参数只能是以‘\0’结尾的字符串，需要在运行时才能计算出来，计算的是字符串的长度；嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环while(1)
{}
for(;;)
{}
loop: ···
goto loop;宏定义写一个标准宏MIN #define MIN(x,y) ( (x)<=(y)? (x):(y) )用预处理指令#define声明一个常数，用以表明1年中有多少秒（忽略闰年问题） #define SEC_YEAR (365 * 24 * 60 * 60)UL用宏定义写出swap（x，y），即交换两数 #define
swap(x,y)
x=x+y;y=x-y;x=x-y;已知一个数组table ，用一个宏定义，求出数据的元素个数 #define LENGTH
sizeof(table)/sizeof(table[0])关键字关键字static的作用是什么修饰局部变量时，变量只执行一次，存在于静态存储区，不初始化内容为0，只在当前语句块有效，程序结束后才释放。修饰全局变量时，变量存在于静态存储区，不初始化内容为0，只在当前文件有效，程序结束后才释放。修饰函数时，该函数只能在当前文件中使用。static函数与普通函数的区别与好处static修饰的函数只能在当前文件使用；普通函数可以被外部文件用extern调用；用static修饰函数的好处是：其他文件可以定义相同名字的函数；该函数不能被其他文件调用；static修饰变量的作用与好处修饰局部变量：存在于静态存储区，不初始化内容为0，作用域在当前函数/语句块；修饰全局变量：存在于静态存储区，不初始化内容为0，作作用域只在当前文件；用static修饰变量的好处是：其他文件可以定义相同名字的变量；该变量不能被其他文件调用；关键字volatile有什么含意？并给出三个不用的例子volatile指的是易变的。用以告诉编译器被volatile修饰的变量随时可能被改变。以下场合需要用到volatile修饰：中断服务程序中修改的供其他程序检测的变量；多任务环境下共享的标志；存储器映射的硬件寄存器；关键字 _interrupt_interrupt是用来定义中断服务子程序ISR的，它有以下几个特点：ISR不能返回一个值；ISR不能传递参数；最好不要做浮点运算；最好不要加打印；关键字const有什么含义const代表着只读，让编译器去保护那些不希望被改变的参数。定义变量，变量的值不能被改变定义指针，指针的值不能被改变定义类的成员函数，成员函数不能改变类的变量以下代码声明的含义是什么const int a;int const a;const int *a;int* const a;const int* const a;a是一个常数整数a是一个常数整数a是一个指向常数整数的指针，指针的值不可修改，但是指针可以修改a是一个指向整数的常量指针，整数的值可以修改，但是指针不可修改a是一个指向const整数的const指针，整数和指针的值都不可以修改不能做switch()的参数类型是什么浮点型。c和c++ 中的struct有什么不同C中的struct不能有成员函数，而C++的struct可以。C中struct的默认权限是public，而C++的struct是private。内存内存最小存储单元以及内存最小计量单元是什么内存最小存储单元是Bit（二进制位）内存最小计量单元是Byte（字节）描述一下内存分区程序在运行前：代码区、BSS段（为未初始化数据区）、data段（初始化数据区）；程序在运行后：堆区、栈区、全局区（静态区）、代码区、文字常量区。stack栈与heap堆的区别stack栈由系统自动分配，其地址和容量是系统定的，是一块连续的内存（Window下是2M）；heap堆是用户自己用malloc申请的，char p = (char)malloc()，它是不连续的。malloc()与new()的区别malloc是在堆中申请内存，申请需要指定大小返回void*类型，需使用强制转换失败返回NULLnew是在自由存储区申请内存，无需指定大小返回对象类型指针，无需转换，安全失败返回mac_alloc异常内存溢出一般是由什么导致的动态申请的空间没有回收数组越界访问变量变量的命名规则变量名由字母、数字、下划线组成，但是不能以下划线开头。变量的声明和定义有什么区别变量的定义需要定义存储空间；变量的声明不需要建立存储空间。描述普通局部变量、普通全局变量、静态局部变量、静态全局变量的区别普通局部变量：存在于栈区，不初始化内容随机，只作用于当前语句块，语句块结束变量空间释放。普通全局变量：存在于全局区，不初始化内容为0，作用于当前文件，也能被其他文件用extern调用，进程结束变量空间才被释放；静态局部变量：存在于静态存储区，不初始化内容为0，作用于复合语句，进程结束变量空间才被释放；静态全局变量：存在于静态存储区，不初始化内容为0，只作用于当前文件，进程结束变量空间才被释放。用变量a进行定义一个整型数 int a一个指向整型数的指针 int *a一个指向指针的指针，它指向的指针是指向一个整型数 int **a一个有10个整型数的数组 int a[10]一个有10指针的数组，该指针是指向一个整型数 int *a[10]一个指向有10个整型数数组的指针 int (*a)[10]一个指向函数的指针，该函数有一个整型数参数并返回一个整型数 int (*a)(int)一个有10个指针的数组，该指针指向一个函数，该函数有一个整型数参数并返回一个整型 int (*a[10])(int)如何定义一个已经引用过的全局变量头文件定义extern调用全局变量可不可以定义在可被多个.C 文件包含的头文件中？为什么？不能，编译器会报多重引用的错误可以在多个c文件中定义相同的全局变量，前提是加static，让该全局变量变为静态全局变量，作用域只在该c文件中。数组数组的特点所有成员都是相同的数据类型所有成员在内存中地址是连续的数组的分类数组的分类有：静态数组、动态数组。静态数组：在程序运行前就确定了大小，且运行中大小不能更改。动态数组：主要是在堆中申请的空间，大小在运行中确定，且可以更改。一维数组在不初始化、部分初始化、完全初始化的区别不初始化：如果是局部数组，内容随机；如果是全局数组，内容为0；部分初始化：未初始化的部分自动补0；完全初始化：数组大小由初始化的个数确定。数组作为类型、作为地址、取地址的区别数组作为类型：代表整个数组的大小；数组作为地址：代表数组首元素地址；数组取地址：代表数组首地址。二维数组在物理和逻辑上的区别在物理上是一维的，在逻辑上是二维的。函数函数的定义与函数的声明有何区别函数的定义：指的是对函数功能的确立，包括函数类型、函数名、形参、函数体。函数的声明：告诉编译器这个函数的类型、名字、形参。宏函数的概念以及作用把一些短而小、使用频繁的函数写成宏函数；由于宏函数没有普通函数的压栈、跳转、返回等开销，可以提高代码效率。对于一个频繁使用的短小函数,在C 语言中应用什么实现，在C++中用什么实现C使用宏定义 #defineC++使用inline关键字指针描述一下32位或64位平台下指针的大小32位平台：任意类型的指针大小为4字节；64位平台：任意类型的指针大小为8字节；指针数组的概念本质是一个数组，数组中的每一个元素都是一个指针。使用realloc给已分配的堆区空间追加空间时需要注意什么用指针变量保存realloc的返回值。什么情况下会出现野指针指针未初始化指针释放后未置空指针操作超出其作用域引用与指针的区别引用必须初始化，指针不必初始化引用初始化后不能被改变，指针可改变引用不可指向空值，指针可指向空值指针作为函数参数的输入特性和输出特性输入特性：主函数分配空间，被调函数使用空间；输出特性：被调函数分配空间，主函数使用空间。(void*)ptr 和 (*(void**))ptr 的结果是否相同？其中ptr为同一个指针一样的。结构体结构体和共用体的区别是啥结构体的成员拥有独立的空间；共用体的成员共用一块空间，并且成员能访问的内存大小由成员自身类型决定。如何理解结构体的浅拷贝和深拷贝当结构体中出现指针成员的时候容易出现浅拷贝和深拷贝的问题。浅拷贝：两个结构体的指针成员指向同一块区域空间，结构体释放时这块空间会被多次释放；深拷贝：两个结构体指针成员指向不空的区域空间，只是内容拷贝一份，结构体释放时不会出现同一个空间被释放多次的情况。文件文件缓冲的几个刷新方式行缓冲满缓冲强制缓冲关闭缓冲谈谈文件的分类文件分为二进制文件和文本文件。二进制文件基于值编码，需要根据具体的应用才能知道某个值的意思；文本文件基于字符编码，一个字节一个意思，可以通过记事本打开。进程进程通信（IPC）的方式管道（pipe/fifo）消息队列共享内存套接字socket信号信号量字节对齐对齐规则规则一：第一个成员的首地址为0。（默认4字节对齐）规则二：每个成员的首地址是自身大小的整数倍。（成员自身对齐）规则三：结构体变量的总大小是结构体里最大的成员的整数倍。(结构体本身对齐)例子1struct test
{
char x1;
short x2;
float x3;
char x4;
};答案：整个结构所占据空间为12字节。例子2#pragma pack(1) //让编译器对这个结构作1字节对齐
struct test
{
char x1;
short x2;
float x3;
char x4;
};
#pragma pack() //取消1字节对齐，恢复为默认4字节对齐这时候sizeof(struct test)的值为8。因为使用伪指令#pragma pack (n)，C编译器将按照n个字节对齐。使用伪指令#pragma pack()，取消自定义字节对齐方式，一般都是成对存在的。#pragma pack (2) /*指定按2字节对齐*/
struct C
{
char b;
int a;
short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/sizeof(struct C)值是8。#pragma pack (1) /*指定按1字节对齐*/
struct D
{
char b;
int a;
short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/sizeof(struct D)值是7。代码* ptr++ 、++* ptr和* ++ptr相同吗？这个* ptr++等价于 * （ptr++），它的作用是先得到 ptr 指向的变量值（* ptr），然后再将ptr+1赋给ptr++*ptr等价于 ++（ *ptr），先解引用再++；*++ptr 等价于 *（++ptr），很容易看出来先对指针移位地址加1再取值；请问以下代码有什么问题int main()
{
char a;
char *str=&a;
strcpy(str,"hello");
printf(str);
return 0;
}没有给str分配空间，将一个字符串复制给一个字符变量指针将会发生异常，因为越界读写导致系统崩溃。 正确修正方法： char a[10];char *str = a;以下代码有什么出错的地方char* s="AAA";
printf("%s",s);
s[0]='B';
printf("%s",s);编译正确，运行错错误，“AAA”是字符串常量，s[0]试图修改字符串常量的指值，字符串常量不能修改。以下代码有什么出错的地方wap( int* p1,int* p2 )
{
int * p;
//(int)malloc(4); is ok
*p = *p1;
*p1 = *p2;
*p2 = *p;
}没有给指针p分配空间，为空指针，无法存储指针p1的值。以下函数执行会出现什么问题void getmemory(char *p)
{
p=(char *) malloc(100);
strcpy(p,“hello world”);
}
int main( )
{
char *str=NULL;
getmemory(str);
printf(“%s/n”,str);
free(str);
return 0;
}定义的*p为局部变量，在函数getmemory外部释放会造成异常，且printf不会有任何输出。编译器总是要为每个参数制作临时副本，getmemory函数，指针参数p的副本是_p，编译器使_p=p。如果函数体内的程序修改了_p的内容，就导致参数p的内容作相应的修改，这就是指针可以用作输出参数的原因。在本例中，_p申请了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变。所以GetMemory并不能输出任何东西。正确用法：void getmemory(char *p)
{
strcpy(p,“hello world”); //内部修改了_p的值，也就修改了p的内容。
}
int main( )
{
char *str = (char *) malloc(100); //在外边初始化字符串指针
getmemory(str);
printf(“%s/n”,str);
free(str);
return 0;
}以下函数执行会出现什么问题void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
} 运行报错，char型指针变量并没有被分配内存空间，所以使用strcpy向它赋值会报错。以下函数执行会出现什么问题char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
} 运行不会报错，但是无法输出hello world，输出结果未知。char p[]是在函数中定义的局部变量，所以函数执行完将被释放回收，以下函数执行会出现什么问题void GetMemory2(char **p, int num)
{
*p = (char *)malloc(num);
printf("*p=%p\n", *p);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
printf("str=%p\n", str);
strcpy(str, "hello");
printf(str);
} 运行没有问题，但是会有内存泄漏的情况，因为malloc申请位置在堆区，需要手动释放。以下函数执行会出现什么问题void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str);
if(str != NULL)
{
strcpy(str, “world”);
printf(str);
}
} 结果无法预测， free(str); 之后str为野指针。以下代码产生什么结果？为什么？char szstr[10];
strcpy(szstr,"0123456789");我们看一下strcpy的作用：strcpy把含有'\0'结束符的字符串复制到另一个地址空间；而str只能装10个字符，0123456789也是10个字符，无法添加\0，所以运行必然会报错。以下代码会出现什么问题？打印结果是是多少？void main()
{
char aa[10];
printf(“%d”,strlen(aa));
}
由于aa[10]没有初始化，所以strlen找不到'\0',打印结果值未知。以下是求一个数的平方的程序,请找出错误:#define SQUARE(a)((a)*(a))
int a=5;
int b;
b=SQUARE(a++);6,30，不是预想的结果。因为宏在预编译的时候会将表达式展开，所以不要在宏中使用++ --方法。编写memcpy函数void* memcpy(void* dest,const void* src,int size)
{
if(dest == NULL
src == NULL)
return dest;
while(size--)
{
*(char*)dest = *(char*)src;
dest = dest+1;
src = src+1;
}
retern dest;
}编写strcpy函数并解释为什么要返回char型char* strcpy(char* strDest,const char* strsSrc)
{
if(strDest == NULL
strSrc == NULL)
return NULL;
char*p = strDest;
while(*strsSrc != '\0')
{
*p = *strSrc;
strSrc = strSrc+1；
p = p+1；
}
*p = *strSrc;
return strDest;
}返回char类型是为了增加灵活性，比如链式操作，例如： int length = strlen( strcpy(str,"Hello World") );计算题unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0x801000;
p2=(unsigned long *)0x810000;
请问p1+5= ;
p2+5= ;0x801005、0x81001432位机unsigned long为4个字节，64位机占8个字节。计算题main()
{
int a[5]={1,2,3,4,5};
int * ptr=(int*)(&a+1);
printf(“%d，%d”,*(a+1),*(ptr-1));
}标准答案：2,5关键点在&a。a既是数据名，又是指向数组第一个元素的指针。sizeof(a)=20, 此时a的类型为int[5]数组。sizeof(a)=4，因为有取值符，表示把a当成一个指针(int*)，而a指向数组的首地址。(&a+1)先取变量a的地址，并根据a的地址获得下一个与a同类型的相邻地址。根据前面所说的a的类型为int[5]数组。&a+1=&a+sizeof(5*int)，因此&a+1指向的地址为 &a[5] (数组a[5]的下一个地址)。如果将&a+1改为a+1，则答案为：1这段代码执行有什么问题？#define Max_CB 500
void LmiQueryCSmd(StructMSgCB * pmsg)
{
unsigned char ucCmdNum;
......
for(ucCmdNum=0;ucCmdNum<Max_CB;ucCmdN
um++)
{
......;
}
会死循环。unsigned char的取值范围为：0-255，而Max_CB最大为500，ucCmdNum无法达到。一句代码实现x是否为2的若干次幂的判断return x&(x-1)?0:1下面的代码输出是什么，为什么？void foo(void)
{
unsigned int a = 6;
int b = -20;
(a+b> 6)? puts("> 6") : puts("<= 6");
}标准答案：输出>6当表达式中存在有符号类型和无符号类型时，所有的数都自动转换为无符号类型。因此-20 变成了一个非常大的正整数，所以该表达式计算出的结果大于6 。下面的代码片段的输出是什么，为什么？char *ptr;
if ((ptr = (char *)malloc(0)) == NULL)
puts("Gota null pointer");
else
puts("Gota valid pointer");标准答案：Got
a
valid
pointermalloc(0)是指分配内存大小为零；NULL是不指向任何实体malloc(0)也是一种存在不是NULL，但是如果对其进行读写操作则会报错。怎么判断链表中是否有环？标准答案：快慢指针法。用两个指针来遍历这个单向链表，第一个指针p1，每次走一步；第二个指针p2，每次走两步；当p2 指针追上p1的时候，就表明链表当中有环路了。Bool hasCycle(ListNode* Head)
{
if(Head == NULL)
return flase;
ListNode* fast = Head;
ListNode* slow = Head;
while(fast != NULL && fast->nest != NULL)
{
slow = slow->next;
fast = fast->next->next;
if(slow == fast)
return ture;
}
return flase;
}排序 从小到大冒泡法就是在每一轮的筛选中找出相邻元素组中较大的那个数。在不断的交换中将当前元素组中最大的数赋值给当前元素组中最后一个元素空间# include<stdio.h>
int main()
{
int a[10] = {6,7,8,9,10,1,2,3,4,5};
int temp;
for(int i=0;i<10;i++)
{
for(int j=0;j<10-i;j++)
{
if(a[j] > a[j+1])
{
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
for(i=0;i<10;i++)
{
printf("out is %d\n",a[i]);
}
return 0;
}我记得曾经有人说过，思想和行动的区别在于：想谈恋爱却高呼自由可贵，想进大厂却不想工作，想当大牛却不想学习，每个人都知道明天必须披荆斩棘的活下去，却依旧浑浑噩噩的度过今天。不用去怀疑自己的能力，你只需要一份靠谱的学习资料，一个学习的deadline以及一个没学完就打爆你狗头的人，很快你就会被自己的才华和能力所惊艳。我收集了一些linux的资料，算法小抄和计算机基础的资料。以下资料仅供个人学习使用，欢迎大家一起学习探讨。linux保姆级教程完整版文档资料希望以上内容能帮助到你，祝各位生活愉快。}