CVTE嵌入式Linux面试

最新推荐文章于 2021-05-05 18:43:33 发布
最新推荐文章于 2021-05-05 18:43:33 发布
阅读量1.1k 收藏 39
点赞数 1
分类专栏： 嵌入式面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36028037/article/details/88653035
版权

2019年cvte春招，嵌入式软件开发面试问题分享。

目录

1.scanf 和 gets 的区别？

2.#define 比较俩个数的大小，输出小的？

3.malloc函数需要注意哪些？ 

4.进程间通信有哪些技术？ 

5.进程、线程并发的技术？ 

6.static关键字

7.怎么知道链表是环状？

8.shell会不会（简单语法）

9.栈、堆、静态内存？

10.二分查找

1.scanf 和 gets 的区别？

scanf是格式化输入，如果只使用最简单的格式化字符串%s，那么scanf只会取一个单词，在输入流中遇到空格/tab/换行，就会结束。比如输入流中有"aa bb cc"的话，那么执行scanf("%s", s)，s的值就会是aa，再次执行这句话，s的值就是bb，第三次就是cc。scanf会从输入流中取多少怎么取，取决于格式化字符串，也就是scanf的第一个参数；而gets则肯定会取出完整的一行。也就是说在scanf中，换行符等同于空格/tab，但gets中，换行符为读取结束标志。

 gets会将输入回车前所有输入的内容取出来，存放到一个字符数组，包括空格/tab，无论这些内容被空格/tab分成了几段，gets都会将这行输入完完整整的放到数组中，通俗点说就是gets会取一行，读到换行为止。

2.#define 比较俩个数的大小，输出小的？

#define out_min(A,B) ((A<=B)?(A):(B))

3.malloc函数需要注意哪些？ 

  1. malloc函数原型为 extern void *malloc(unsigned int num_bytes);使用的时候要进行类型转换；
  2. malloc函数使用后必须free；

4.进程间通信有哪些技术？ 

  • 管道

管道分为未名管道和命名管道，使用时要注意以下几点：

1.管道是半双工的，双向通信需要建立俩个管道；

2.管道从尾部写入，从头部读出；

3.管道里的内容被读出以后，会自动删除；

4.多进程对管道操作时要加锁；

5.读写端关闭的管道返回0；

6.写读端关闭的管道出错，产生信号SIGPIPE；

7.管道空了read会阻塞，管道满了write也会阻塞，可以设置为非阻塞；

未名管道操作流程（框架）：

/*未名管道只能用于有亲属关系的进程间的通信*/
int fd[2];
pipe(fd[2]);
pid_t pid = fork();
if(pid < 0){             //error
    perror("fork error");
    exit(1);
}else if(pid > 0){       //parent
    close(fd[0]);        //关闭读端
    ……
    close(fd[1]);
    wait(0);
}else{                   //child
    close(fd[1]);        //关闭写端
    ……
    close(fd[0]);
}

命名管道操作流程（框架）

/*
 * 命名管道可以用于任意俩个进程间通信
 * fifo的创建：
 * shell下：mkfifo FIFO
 * C语言函数:int mkfifo(const char *pathname, mode_t mode);
 * 如果该程序创建好了一个管道，那么这个管道就会一直存在；该文件如果已经存在，那么创建就会失败；
 */

//read
fifo_fd = open(fifo_name, O_RDONLY | O_NONBLOCK);
if(fifo_fd < 0){
    perror("open error\n");
    exit(1);
}else{
    printf("open success\n");
}
char readbuff[512];
memset(readbuff, 0, sizeof(readbuff));
while(read(fifo_fd, readbuff, sizeof(readbuff)) < 0){
    perror("read error");
    exit(1);
}
printf("%s\n", readbuff);

close(fifo_fd);

//write
fifo_fd = open(fifo_name, O_WRONLY);
if(fifo_fd < 0){
    perror("open error\n");
    exit(1);
}else{
    printf("open success\n");
}
char *buf = "123456789";
size_t size = strlen(buf);
if(write(fifo_fd, buf, size) != size){
    perror("write error\n");
    exit(1);
}
close(fifo_fd);

  • 消息队列

消息队列特点

  1. 消息队列一直存在于内核之中，除非调用命令删除；
  2. 消息队列可是双向通信
  3. 消息队列的数据块可以有类型

关键函数

//创建、获得消息队列
int msgget(key_t key, int msgflg);
key 	    ftok(path,0);	//系统创建一个唯一的
		    IPC_PRIVATE  	//系统提供一个唯一的
		    一个大于0的数	//用户提供一个唯一的

msgflag   
IPC_CREAT如果内核中没有此队列，则创建它。
IPC_EXCL当和IPC_CREAT一起使用时，如果队列已经存在，则失败。
		
//向消息队列发送消息
msgsnd(int msqid, const void *msgp, size_t msg, int msgflg);

msqid      
消息队列标识

*msgp     
要发送的消息

msg       
发送的消息长度，要减去sizeof(long)不包括消息类型的长整形

msgflg    
0：当消息队列满时，msgsnd将会阻塞，直到消息能写进消息队列
IPC_NOWAIT：当消息队列已满的时候，msgsnd函数不等待立即返回
IPC_NOERROR：若发送的消息大于size字节，则把该消息截断，截断部分将被丢弃，且不通知发送进程。
//从消息队列接收消息
msgrcv(int msqid, void* msgp, size_t msgsz, long msgtype, int msgflg);
msqid
消息队列标识符

msgp
存放消息的结构体，结构体类型要与msgsnd函数发送的类型相同

msgsz
要接收消息的大小，不含消息类型占用的4个字节

msgtyp
0：接收第一个消息
>0：接收类型等于msgtyp的第一个消息
<0：接收类型等于或者小于msgtyp绝对值的第一个消息

msgflg
0: 阻塞式接收消息，没有该类型的消息msgrcv函数一直阻塞等待
IPC_NOWAIT：如果没有返回条件的消息调用立即返回，此时错误码为ENOMSG
IPC_EXCEPT：与msgtype配合使用返回队列中第一个类型不为msgtype的消息
IPC_NOERROR：如果队列中满足条件的消息内容大于所请求的size字节，则把该消息截断，截断部分将被丢弃

//消息队列控制函数
msgctl(int msqid, int cmd, struct msqid_ds *buf);
msqid	  
消息队列id

cmd	  
IPC_STAT 获取消息队列的信息
IPC_SET  设置消息队列的信息
IPC_RMID 删除消息队列

msqid_ds
修改时间；修改对象；队列长度；

 

消息队列的使用 

/*向消息队列发送消息*/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>


typedef struct{     
	long	type;	//消息类型
	int		start;	//消息数据本身（包括start和end）
	int		end;
}MSG;

/*
 * 往消息队列中发送消息
 */

int main(int argc, char *argv[])
{
	if(argc < 2){
		printf("usage: %s key\n", argv[0]);
		exit(1);
	}

	key_t key = atoi(argv[1]);        //手动输入一个唯一的值
	//key_t key = IPC_PRIVATE;        //系统提供
	//key_t key = ftok(argv[1], 0);   //系统提供，传参为路径名字
	printf("key: %d\n", key);

	//创建消息队列
	int msq_id;
	if((msq_id = msgget(key,         //IPC_CREAT|IPC_EXCL表示如果队列已经存在则失败
				IPC_CREAT|IPC_EXCL|0777)) < 0){
		perror("msgget error");
	}
	
	printf("msg id: %d\n", msq_id);
	
	//定义要发送的消息
	//{消息类型， 消息内容， 消息内容}
	MSG m1 = {4, 4, 400};
	MSG m2 = {2, 2, 200};
	MSG m3 = {1, 1, 100};
	MSG m4 = {6, 6, 600};
	MSG m5 = {6, 60, 6000};
	
	//发送消息到消息队列
	if(msgsnd(msq_id, &m1,
			sizeof(MSG)-sizeof(long), IPC_NOWAIT) < 0){    //减去数据类型的大小
		perror("msgsnd error");	
	}
	if(msgsnd(msq_id, &m2,
			sizeof(MSG)-sizeof(long), IPC_NOWAIT) < 0){
		perror("msgsnd error");	
	}
	if(msgsnd(msq_id, &m3,
			sizeof(MSG)-sizeof(long), IPC_NOWAIT) < 0){
		perror("msgsnd error");	
	}
	if(msgsnd(msq_id, &m4,
			sizeof(MSG)-sizeof(long), IPC_NOWAIT) < 0){
		perror("msgsnd error");	
	}
	if(msgsnd(msq_id, &m5,
			sizeof(MSG)-sizeof(long), IPC_NOWAIT) < 0){
		perror("msgsnd error");	
	}

	//发送消息队列中消息的总数
	struct msqid_ds ds;
	if(msgctl(msq_id, IPC_STAT, &ds) < 0){
		perror("msgctl error");
	}
	printf("msg total: %ld\n", ds.msg_qnum);

	exit(0);
}


/*从消息队列中读取数据*/

#include <sys/msg.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct{
	long	type;
	int		start;
	int		end;
}MSG;

int main(int argc, char *argv[])
{
	if(argc < 3){
		printf("usage: %s key type\n", argv[0]);
		exit(1);
	}

	key_t	key = atoi(argv[1]);
	long	type = atoi(argv[2]);

	//获得指定的消息队列
	int msq_id;
	if((msq_id = msgget(key, 0777)) < 0){
		perror("msgget error");
	}
	printf("msg id: %d\n", msq_id);
	
	//从消息队列中接受指定类型的消息
	MSG m;
	if(msgrcv(msq_id, &m, 
		sizeof(MSG)-sizeof(long), type, IPC_NOWAIT) < 0){
		perror("msgrcv error");	
	}else{
		printf("type: %ld start: %d end: %d\n",
						m.type, m.start, m.end);
	}

	exit(0);
}

 

  • 共享内存

共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。
         
        (1)创建共享内存    int shmget(key_t key, size_t size, int shmflg)
                返回 共享内存标识符
                key    共享内存段的命名
                size    size以字节为单位指定的内存容量
                shmflg    权限标志 与open函数一样
        (2)共享内存映射 void *shmat(int shm_id, const void *shm_addr, int shmflg)
        第一次创建的共享内存还不能被任何进程访问，序用通过shmat映射
        shm_id        共享内存的标识
        shm_addr    连接到当前进程的地址，通常为空，让系统来选择共享内存的地址
        shmflag        通常为0
        调用成功返回共享内存第一个字节的指针

        
        ④函数进行分离（本进程对共享存储段操作结束时的步骤，并不是从系统中删除共享内存和结构）
        int shmdt(const void *shmaddr)
        
        ⑤控制共享内存 shmctl(int shm_id, int command, struct shmid_ds *buf)
        shm_id:        内存标识符
        command:    IPC_STAT:读取共享内存的信息
                             IPC_SET: 设置共享内存的信息
                             IPC_RMID:删除共享内存段

  • 信号

信号的基本概念

不可靠信号：

也称为非实时信号，不支持排队，信号可能会丢失, 比如发送多次相同的信号, 进程只能收到一次. 信号值取值区间为1~31；

可靠信号：

也称为实时信号，支持排队, 信号不会丢失, 发多少次, 就可以收到多少次. 信号值取值区间为32~64

在终端可以通过 kill -l 命令查看所有的信号。

信号的产生

（1）用户自己输入，如按下Ctrl+C，产生SIGINT信号；

（2）产生硬件异常，如CPU监测到内存的违法访问；

  1. 硬件方式产生
  2. 软件产生方式
1.int kill(pid_t pid, int sig);    //用于向任何进程组或进程发送信号
pid:
    pid > 0:  发送给进程号为pid的的进程
    pid == 0:  发送给调用kill()的同组进程
    pid == -1: 发送给所有本进程有权限发给的进程
    pid < -1: 发送给-pid组的进程
sig:
准备发送的信号代码，假如其值为零则没有任何信号送出，但是系统会执行错误检查，通常会利用sig值为零来检验某个进程是否仍在执行。

返回值：
成功返回0；
失败返回-1，并设定errno的值：
errno == EINVAL:指定的sig无效
errno == EPERM:权限不够，无法发送给某进程
errno == ESRCH：参数pid所指定的进程或进程组不存在

2.unsigned int alarm(unsigned int seconds); //用于调用进程指定时间后发出SIGALARM信号；
seconds:
表示秒数
函数返回值
成功：如果调用此alarm（）前，进程已经设置了闹钟时间，则返回上一个闹钟时间的剩余时间，否则返回0。
出错：-1
如果用alarm()函数作为定时器，每次处理以后，都要再次调用alarm()函数

4.setitimer()：设置定时器，计时达到后给进程发送SIGALRM信号，功能比alarm更强大；

5.int raise(int signo)：用于向进程自身发送信号；

信号的处理

进程对信号的处理方式： 有3种

  • 默认 接收到信号后按默认的行为处理该信号。 这是多数应用采取的处理方式；
  • 自定义 用自定义的信号处理函数来执行特定的动作；
  • 忽略 接收到信号后不做任何反应；

函数 void (*signal(int sig, void (*func)(int)))(int) 设置一个函数来处理信号；

函数原型的解读：

中间部分signal(int sig, void (*func)(int)）俩个参数，第一个参数sig为要登记的信号类型，第二个参数为一个带int参数的函数指针；

外围部分 void (*signel(xxxx)(int))   signal函数返回的是一个函数指针，无返回值，有一个int参数;

参数sig：

要登记处理函数的信号，如SIGINT;

参数 void(*func)(int):

可以是一个函数指针；也可以是SIG_DFL：默认的信号处理程序；SIG_IGN：忽视信号。

例子

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

//定义信号处理函数
//signo: 进程所捕获的信号
void sig_handler(int signo)
{
	printf("%d, %d occrued\n", getpid(), signo);
}

int main(void)
{
	//向内核登记信号处理函数以及信号值
	if(signal(SIGTSTP, sig_handler) == SIG_ERR)
	{
		perror("signal sigtstp error");
	}

	if(signal(SIGINT, sig_handler) == SIG_ERR)
	{
		perror("signal sigint error");
	}

	if(signal(SIGUSR1, sig_handler) == SIG_ERR)
	{
		perror("signal sigusr1 error");
	}
	
	if(signal(SIGUSR2, sig_handler) == SIG_ERR)
	{
		perror("signal sigusr2 error");
	}

	int i = 0;
	while(i < 20)
	{
		printf("%d out %d\n", getpid(), i++);
		sleep(1);
	}
	raise(SIGUSR1);
	kill(getpid(), SIGUSR2);
	return 0;
}

  • socket

用于处于不同主机的俩个主机相互通信。

5.进程、线程并发的技术？ 

互斥锁

        基本流程：
        1.初始化一个互斥锁:pthread_mutex_init(pthread_mutex_t *mutex, NULL);
        2.加锁    pthread_mutex_lock(pthread_mutex_t *mutex):加锁失败阻塞
                      pthread_mutex_trylock()：加锁失败返回错误码
        3.对共享资源进行操作
        4.解锁    pthread_mutex_unlock()
        5.注销互斥锁：pthread_mutex_destroy(pthread_mutex_t *mutex)  

读写锁

读写锁的状态：1.读模式下的加锁；2.写模式下的加锁；3.无锁；
        没有写模式下的加锁，任意线程都可以进行读模式的加锁；
        只有读写不加锁的状态下，才能进行写模式的加锁；
        
        使用步骤：
        1.初始化
        2.设置读写锁属性
        3.使用读写锁
        4.销毁读写锁

信号量

        信号量:特殊的变量，访问具有原子性；
        使用信号量解决进程或者线程之间的共享资源引发的同步问题；
        
        使用步骤：
        1.新建信号量    int semget(key_t key, int num_sems, int sem_flags);
                返回：信号量标识符
                key:信号量标记
                num_sems:信号量的数量，一般为1
                flags:    IPC_CREATE:如果信号量存在，返回标识符
                    IPC_EXCL:如果信号量存在，返回错误-1
        2.修改信号量的值（在PV操作里调用）
                int semop(int sem_id, struct sembuf *sem_opa, size_t num_sem_ops);
                sem_id:信号量标识符
                sem_opa:指向信号量操作数
                sem_ops:opsptr中元素的个数
        3.信号量的控制    int semctl(int semid, int semnum, int cmd, /*可选参数*/);
                semid:信号量标识
                semnum:指定哪个信号
                cmd:    IPC_STAT:读取信号量结构体
                    IPC_SET:设置信号量结构体
                    IPC_RMID:将信号量从内存中删除
                    SETVAL:设置信号量中一个单独信号量的值
        

6.static关键字

  1. 用于修饰函数里变量时，变量存在静态内存，函数退出后不会释放；
  2. 用于修饰全局变量，该全局变量只能在本文件中使用；
  3. 用于修饰函数的时候，该函数只能在本文件中使用；

7.怎么知道链表是环状？

思路：设置俩个快慢指针（快慢指针即俩个指针的起点相同，慢指针每次走一步，快指针每次走俩步），让他们一直往下走，如果他们相等说明有环；遇到nullptr则说明无环。

8.shell会不会（简单语法）

	1.变量：
		a.定义时没有$ b.变量名和等号之间不能有空格 c.使用变量${变量名}
		使用变量的时候$ 不使用的不加$
		readonly 只读变量 修改值会报错
		unset可以删除变量
		
		单引号里的字符无论如何都会原样输出
		双引号里可以有转义字符可以有变量
		
		默认变量： 	$#	输出命令行参数的个数
				    $*	输出所有的变量
				    $0	shell命令本身
				    $1	输出第一个参数
		局部变量	local 只在定义的函数中有效
	2.if语句
		if [ $a = $b ] 
		then	
			#code
		fi
  	3.判断
	[-r"$folder"]&&echo"Can read"			    &&前面为真后边执行
	[-f"$folder"]||echo"this is not file"		||前面为假后边执行
	
	4.for
		for var in [list]		var不加$
		do
			#			循环体中var加$
		done
	5.while until
		while[]
		do
			#
		done
	6.case
	case "$vsr"in
		condition1)
		;;
		condirion2)
		;;
		*)	;;
	esac

 

9.栈、堆、静态内存？

1.栈存放局部变量、函数调用上下文、函数参数、函数返回地址

栈上的数据在函数返回后就会被释放掉，无法传递到函数外部，如：局部数组；

2.堆

堆中被程序申请使用的内存在程序主动释放前将一直有效

堆空间通过申请才能获得

3.静态内存存放全局变量和静态变量

静态变量的空间在编译的时候就确认了

静态变量的存储信息会存在可执行程序中

静态变量会一直存在，直到程序结束

10.二分查找

 

/* 函数BinarySeach，在包含size个元素的、从小到大排序的int数组a里查找元素p，如果查到了返回元素的下 
 * 标，如果找不到，返回-1.
 */
int BinarySearch(int a[], int size, int p)
{
    int L = 0;                //左端点
    int R = size - 1;         //右端点
    while(L <= R){
        int mid = L+(R-L)/2;    //取查找正中元素下标
        if( p == a[mid]){
            return mid;
        }else if(p > a[mid]){
            L = mid + 1;
        }else{
            R = mid - 1;
        }
    }
    return -1;
}
/* 函数LowerBound，在包含size个元素的、从小到大排序的int数组a里查找比给定整数p小的，下标最大的元
 * 素。找到则返回其下标，找不到返回-1
 */

int LowerBound(int a[], int size, int p)
{
    int L = 0;             //左端点
    int R = size -1;       //右端点
    int lastPos = -1;      //到目前为止找到的最优解
    while(L <= R){
        int mid = L + (R-L)/2;
        if(a[mid] > p){
            R = mid - 1;
        }else{
            lastPos = mid;
            L = mid+1;
        }
    } 
    return lastPos;
}

 

Zoro_97
关注
  • 1
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CVTE 等公司的嵌入式面试
weixin_42536940的博客
06-22 1225
嵌入式面试常见题目
Linux系统调用--msgsnd/msgrcv函数详解
08-04 1万+
【msgsnd/msgrcv系统调用】       功能描述： 在消息队列上进行收发消息。为了发送消息，调用进程对消息队列必须有写权能。接收消息时必须有读权能。 用法：  #include #include #include int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);ssize_t msg
msgsnd函数 msgrcv函数的一些小问题（IPC_NOWAIT慎用！）
Yannie's Blog
10-31 1万+
这两个函数别看它简单，真的是一不小心就会出错的啊 报错1：msgsnd: Invalid argument msgrcv: Argument list too long 这真的是一个最常见的错误了。。。归根究底是缓冲区长度的问题 1⃣️这个问题我出错后修复之后竟然无法重现错误了。。。等我下次遇到了再补这个错误吧，反正肯定就是缓冲区长度问题。 我写的代码如下,输出结果竟然为 *** cbytes: ...
（2022）CVTE嵌入式笔试题.pdf
09-24
CVTE嵌入式笔试题 本资源为CVTE嵌入式笔试题，共27题，涵盖了嵌入式系统、操作系统、计算机网络、数据结构、算法等多个领域。 1.N个顶点的强连通图至少有多少条边？答：至少有N条边。强连通图是指任意两点之间存在...
CVTE嵌入式题（单片机方向2022）.docx
10-12
CVTE嵌入式
嵌入式软件开发面试题整理
10-19
"嵌入式软件开发面试题整理" 本资源摘要信息涵盖了嵌入式软件开发面试中常见的问题和知识点，包括关键字volatile、static、const的含义和作用，变量修饰符的区别，函数指针、ISR、中断服务子程序、union和struct的...
嵌入式面试题.zip
04-01
嵌入式技术是一种将计算机硬件和软件...总的来说，准备嵌入式面试需要全面掌握嵌入式系统的基础知识，深入理解硬件与软件的交互，并具备良好的编程能力和实践经验。同时，关注行业动态和技术趋势也是提升竞争力的关键。
CVTE_嵌入式-常用知识&面试题库_大厂面试真题.rar
08-07
在"CVTE_嵌入式-常用知识&面试题库_大厂面试真题.rar"这个压缩包中，我们可以预见到它包含了关于嵌入式系统的常见知识点以及在大公司面试时可能会遇到的问题。 1. **嵌入式系统基础知识**： - 嵌入式系统的定义：...
关于Linux系统消息队列中出现的msgsnd与msgrcv使用出现的问题分析：
weixin_42678510的博客
09-12 2389
关于Linux系统消息队列中出现的msgsnd与msgrcv使用出现的问题分析： 1：msgsnd出现identifier removed： int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); 说明msqid出现了问题，查找之上找到问题是： 红...
linux msgrcv()
cffishappy的专栏
12-02 1万+
msgrcv()函数被用来从消息队列中取出消息。它在linux/msg.h 中的定义是这样的： 系统调用： msgrcv() 函数声明： int msgrcv ( int msqid, struct msgbuf *msgp, int msgsz, long mtype, int msgflg ) 返回值： Number of bytes copied into message buf
CVTE 嵌入式软件工程师 面试+笔试
往事撩人醉的博客
03-08 6264
一面： 在网上做完了测评之后，当天就收到面试的通知了，CVTE效率真高。第二天就去参加面试，面试前紧张了一把，后来去到之后发现只有几个应聘者，很多面试官前面都没人，估计现在中午一点，所以都去吃饭了。我和一个同学去，直接就面试了。我面的是技术类的岗位。 一面没有问技术，只是问问简历上写的东西。HR有2个人，同时面试我们3个人。以下是HR问的问题： 你为什么要应聘这个职位？ 你的成绩排...
线程的几种锁及基本操作
热门推荐
czf的编程工坊
05-05 3万+
互斥锁： 1.定义互斥量： pthread_mutex_t mutex; 2.初始化互斥量： pthread_mutex_init(&mutex, NULL); //第二个参数不研究置NULL;          //初始化为 1 （仅做记忆） 3.上锁      pthread_mutex_lock(&mutex);   1->0;    0   等待 4.解锁           
cvte在线测评题总结
a1233499590050的博客
04-22 4234
（1）linux内核配置命令（选择题） make mrproper--清理全部文件，包括.config和一些备份文件 make clean --清理生成文件，但会保留.config和一些模块文件 make defconfig---生成包含全部默认选项的.config文件（有） make oldconfig--在旧的.config基础上生成新的.config make config--基于
CVTE 2018年暑期 嵌入式应用开发实习生 面试经历
欢迎来到我的空间
05-31 7008
错过了CVTE 2018年 暑期实习生的招聘，参加的是在这之后的内推，还是蛮幸运的，从4月中旬投简历到5月中旬也是顺利的通过了所有的面试，现在把面试的经验分享给大家，希望对大家有帮助。 简历筛选 自己上传了一个简历，又按照官网上的填写了一份，主要就是项目经验和获奖情况。 大部分都是直接从我之前简历赋值粘贴的，不过还是觉的我自己做的简历花里胡哨比较好看。 技术面试一 远程电话联系，我们几个小...
linux嵌入式面试300问,经典嵌入式Linux面试题3问
weixin_30802953的博客
05-05 3890
题一:简述memcpy和strcpy的区别？题二：信号量与互斥锁的区别？题三：简述程序编译的过程？ 题一答案：(1)、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。(2)、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"0"才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。(3)、用途不同。...
CVTE嵌入式面试题
最新发布
11-10
很抱歉，根据提供的引用内容，无法提供CVTE嵌入式面试题的具体内容。但是，可以给出一些关于嵌入式面试的一般性建议： 1. 熟悉嵌入式系统的硬件架构和软件分层，了解常用的嵌入式处理器和微控制器； 2. 掌握C/C++等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值