VIVO笔试题

1、字符串变量和字符创常量比较

#include <iostream>

using namespace std;

int a=2;
const int  b=2;
int c=3;

int main (void) {
	int d=1;
	int e=1;
	const int f=3;
    char str1[] = "abc";
    char str2[] = "abc";
    const char str3[] = "abc";
    const char str4[] = "abc";
    const char* str5 = "abc";
    const char* str6 = "abc";
    
    cout << "&str1 =" << &str1 << endl;
    cout << "&str2 =" << &str2 << endl;
    cout << "&str3 =" << &str3 << endl;
    cout << "&str4 =" << &str4 << endl;
    cout << "&str5 =" << &str5 << endl;
    cout << "&str6 =" << &str6 << endl;
    
    cout <<  "&a = "  << &a << endl;
    cout <<  "&b = "  << &b << endl;
    cout <<  "&c = "  << &c << endl;
    cout <<  "&d = "  << &d << endl;
    cout <<  "&e = "  << &e << endl;
	cout <<  "&f = "  << &f << endl;
	
	printf("str1 val = %d ,str2 val = %d \n",str1,str2);
	printf("str3 val = %d ,str4 val = %d \n",str3,str4);
	printf("str5 val = %d ,str6 val = %d \n",str5,str6);

    cout << (str1 == str2) << endl;
    cout << (str3 == str4) << endl;
    cout << (str5 == str6) << endl;

    return 0;
}

 

输出：false，false，true

第一个，第二个存储的都是局部数组，指针变量自身或数组和指向的字符串都存储在栈中。第三个，指针变量自身属于自动变量，存储在栈中。指向的字符串常量存储在静态存储区。

三种比较都是比较变量自身存储的地址。字符串常量在整个程序中只保存一个。因此指向相同的地址。

全局const常量和全局普通常量都存储在静态存储区，但是不连续存储。

局部const常量和局部普通常量都存储在栈中，连续存储，按定义顺序。

Const变量修改是在编译阶段检查的。所以不需要在内存级别设置访问权限。

7、在ARM集成开发环境中：

    1）只读的代码段和常量被称作RO段，是程序中的指令和常量；

    2）可读写的全局变量和静态变量称为RW段，是程序中已初始化变量；

    3）RW段中要被初始化为0的变量称为ZI段，是程序中未初始化变量。

只有只读的指令和常量可以共享。

8、线程共享的进程环境包括：

• 进程代码段
• 进程的公有资源（如全局变量，利用这些共享的数据，线程很容易的实现相互之间的通信）
• 进程打开的文件描述符
• 消息队列
• 信号的处理器
• 进程的当前目录
• 进程用户ID
• 进程组ID

线程独占资源：

• 线程ID
• 寄存器组的值
• 用户栈、内核栈（在一个进程的线程共享堆区（heap））
• 错误返回码
• 线程的信号屏蔽码
• 线程的优先级

9、Linux系统信号：发送信号的系统调用：kill()。

10、循环队列：牺牲一个存储空间，来判断队列空还是队列满。Q.front == (Q.rear+1)%Q.size。队头指针在队尾指针的下一位置时，队满。

20、malloc分配失败的原因：1、请求长度过大2、内存碎片3、内存不足

27、sprintf、strcpy、strncpy及 memcpy 函数：

sprintf：把格式化字符串写入某个字符串，对写入buffer的字符数没有限制，存在溢出可能；

strcpy：把src开始以\0结尾的字符串复制到以dest为开始的地址空间，dest可能空间不够存放；复制以‘\0’结束。

strncpy：把src所指向的字符串中以src地址开始的前n个字节复制到dest所指的数组中，并返回dest，可以避免缓存不够，但是src大于dest时可能出现乱码，可以把dest末尾置空来避免；

memcpy：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中，src和dest有可能出现空间重叠，它可以复制任何内容；

编程题：

1、约瑟夫环是一个数学应用题：已知n个人（编号1、2、..n）围坐在一张圆桌周围。从编号为1的人开始报数，数到m的那个人出列；他的下一个又从1开始报数，数到m的那个人又出列；依次规律重复下去，直到圆桌周围的人全部出列。请编写一个程序，给定n、m计算出列人员先后顺序。

思路：首先需要将圆桌抽象为循环链表，每次一个人出列，类似于从循环链表中删除一个人。删除一个元素需要前一个的指针，因此需要保存前一个元素的指针变量。

void fun(n,m){
	struct List *L = create(n);
	struct List *p = L,*cur=L;
	struct List *pre = L;
	int count=0,cyc;
	int n0 = n;
	int *arr = (int *)malloc(sizeof(int)*n);
	while(--n){/*求第一个元素的上一个元素*/
		pre = cur->next;
		cur = cur->next;
	}
	cur = pre->next;
	printf("%d %d \n",pre->i,cur->i);

	while(count < n0){
		cyc = m;
		while(--cyc){
			pre = cur;
			cur = cur->next;
		}
		arr[count] = cur->i;
		printf("count=%d, inode =%d\n",count,arr[count]);
		pre->next = cur->next;
		cur = cur->next;
		count++;
	}
}

2、编程找出两个字符串中最大公共子字符串,如"abccade","dgcadde"的最大子串为"cad"。

思路：构建一个二维矩阵，记录两个字符串相等的字符和子串。

char *find(char const *str1,char const *str2){
	int str1_len = strlen(str1);
	int str2_len = strlen(str2);
	int arr[str1_len][str2_len];
	int i,j,max_i,max_j,max=0;
	
	for(i=0;i<str1_len;i++){
		for(j=0;j<str2_len;j++){
			if(*(str1+i) == *(str2+j)){
				if(i==0 || j==0)
					arr[i][j] = 1;
				else
					arr[i][j] = arr[i-1][j-1]+1;
				if(arr[i][j] > max){
					max = arr[i][j];
					max_i = i;
					max_j = j;
				}
			}
			else
				arr[i][j] = 0;
		}
		
	}
	char *res = (char *)malloc(sizeof(char)*(max+1));
	res[max] = '\0';
	for(;max--;max_i--,max_j--){
		if(arr[max_i][max_j]) 
			res[max] = str1[max_i];
	}
	return res;
}