C笔试常见考点

强制类型转换

隐式：默认把有符号数，转换为无符号数
显式：（强制转换类型）

字符串“\0”字符

static关键字

1.修饰局部变量时：
延长生命周期同时，该局部将存放在全局变量所在的区域。
2.修饰全局变量或函数时：
该全局变量或者函数只能在本文件中使用，不能用extern声明后在其他文件中调用。

const关键字

作用：被修饰的变量，变为只读属性，不能被更改，增加程序的健壮性。
1.修饰的变量不能被改变，但是可以通过指针更改
2.修饰指针时：

const char *p; // *p不能改变，p可以改变
char const *p; // *p不能改变，p可以改变
char * const p;// p不能改变，*p可以改变
const char * const p;// *p 和 p都不能改变

volatile关键字

被修饰变量，每次读取时都要从内存中读取，防止出现意外。
（最常见的例子是，修饰传感器等外设寄存器内存放的数据，因为这些变量可能被意外的改变）
程序中的例子：

int a = 3;
int b = (++a)+(++a);
printf("a = %d\n",b);
/**
 * 编译器不同，结果为8或者10。不会是9。
 * 当变量a用volatile修饰之后结果为9。
 */

逗号运算符

int a[3][2]={{0,1},{2,3},{4,5}};
int a[3][2]={(0,1),(2,3),(4,5)};

宏替换

#define YEAR_S (365*24*60*60)//在编译时计算，不会影响效率  
#define SQR(x) ((x)*(x))//一定要加括号  

typedef

格式：typedef int myint;
作用：给数据类型其别名
例子：函数指针类型。

重写并实现以下几个函数

strcat

char* mystrcat(char *str1,const char* str2)
{
    char *str = str1;
    while(*str1 != '\0') str1++;
    while(*str2 != '\0')
    {
        *str1 = *str2;
        str1++;str2++;
    }
    return str;
}

strcpy

char* mystrcpy(char *str1,const char* str2)
{
    char * str = str1;
    while(*str != '\0')
    {
        *str = *str2;
        str++;str2++;
    }
    return str1;
}

strcmp

int mystrcmp(char *str1,const char* str2)
{
    while(*str1 != '\0')
    {
        if(*str1 > *str2)
            return 1;
        else if(*str1 < *str2)
            return -1;
        str1++;str2++;
    }
    return 0;
}

atoi

#include <stdio.h>
#include <ctype.h>

//isspace跳过空格和/t
//isdigit判断是不是数字
int atoi(char s[])
{
    int i,n,sign;
    for(i=0;isspace(s[i]);i++)//跳过空白符;

    if(s[i]=='+'||s[i]==' -')//跳过符号
    {
        sign=(s[i]=='-')?-1:1;
        i++;
    }
    for(n=0;isdigit(s[i]);i++)
       n=10*n+(s[i]-'0');//将数字字符转换成整形数字
    return sign *n;
}

字符串逆序

全局变量 与 局部变量的区别

全局变量生命周期长，在程序创建时产生，随着程序结束而消失。
    在全局都可以访问和使用。
局部变量生命周期短，在函数调用时产生，在函数结束时消失。
    仅在局部有效。

堆 和 栈的区别

栈是先进后出，局部变量存放在栈区。
    局部变量在函数执行前入栈（自动申请空间），执行后出栈（自动释放）。不受程序员直接控制  
    linux中，进程的栈区是向下生长的，ARM架构是满减栈
堆是需要手动申请，手动释放的。
    linux中，堆是向下生长的。对上申请的空间只要没被释放，并且知道地址就可以访问。

网络 TCP UDP

TCP
安全可靠
需要三次握手，四次挥手

UDP
速度快，但是不安全

ARM 中断

当出现中断时，打断现在在做的事，优先处理中断。
中断事件结束后，继续做原来的事情。

底层 I2C

脚本：获取某个正在执行的程序的PID，并根据这个PID杀死它

#!/bin/bash

#找到从命令行传入的名字的进程的详细信息
ps -el | grep "$1" -n

#找到从命令行传来的名字的进程的PID
pe -e | grep "$1" | cut -d " " -f 2

#找到从命令行传来的名字的进程的PID，并杀死
kill -9 `ps -e | grep "$1" | cut -d " " -f 2`

++ *的优先级

都是单目运算符时 大于++（因为 也有可能是双目运算符乘号）
另：单目运算符优先级高于双目

int a[6] = {1,2,3,4,5,6};

2[a] ==== a[2]

ascii 的八进制 表示形式

二进制 111 1011
八进制 0173
十进制 123
十六进制 0x7b

使用结构体和共用体完成高低位翻转

union m{
    int a;
    struct c{
      char a1;
      char a2;
      char a3;
      char a4;
    }b;
};
int fun(int arg)
    char temp;
    union m my;
    my.a= arg;
    temp = my.b.a1;
    my.b.a1 = my.b.a4;
    my.b.a4 = temp;
    temp = my.b.a2;
    my.b.a2 = my.b.a3;
    my.b.a3 = temp;
    return my.a;
}

malloc() 与 free() 函数

char *p = (char *)malloc(空间的大小【字节】);  
free(p);  

指针：

数组         指针
a[]   <===> *p  
* a[] <===> **p  
a[][] <===> (*p)[]  

数组：

一维数组和二维数组

函数指针数组定义：

函数指针                函数原型
void(*p)(int) <===> void fun(int)  

不用第三变量实现两个变量值的交换

法1：加减法

a = a + b;
b = a - b;
a = a - b;
优点：易理解，可用于浮点型
缺点：有范围限制，A+B大于取值范围时会出错

法2：异或法

a = a ^ b;
b = a ^ b;
a = a ^ b;
优点：交换速度快
弊端：难理解，对于浮点型束手无策

判断一个数的二进制有多少个位为1

法2效率更高，有几位循环几次
法1：与移位法

void totalOne(int x)  
{  
    int count = 0;  

    while(x)  
    {  
        if(x & (1<<31))
            count++;
        x << 1;
    }  
    printf("count = %d/n", count);  
} 

法2：与减法

// 判断一个整数的二进制位中有多少个1  
void totalOne(int x)  
{  
    int count = 0;  

    while(x)  
    {  
        x = x & ( x - 1 );  
       count++;   
    }  
    printf("count = %d/n", count);  
}