Linux/C/C++题目汇总

所有题目来自网络，个人总结，持续更新

更新记录

• 0317首次添加

一：简述题

1.1 new malloc差别

1. new为关键字，malloc为库函数
2. 使用new申请内存无需指定内存大小，malloc需要显示的给出所需内存的大小
3. new分配成功返回的是对象类型指针，与对象严格匹配，无需类型转换，故new是符合类型安全性操作符，malloc返回的是void*
4. 分配失败：new分配失败，抛出bad_alloc异常，malloc则是返回NULL
5. 重载
6. 内存区域：new分配的内存在自由储存区，malloc在堆上分配

1.2 static各种情况不同

1. 静态全局变量 和普通全局变量
2. 静态变量与普通局部变量
3. 静态函数和普通函数
4. 作用域、生存期问题

1.3 重写、重载、隐藏区别

1. 重载/被重载的函数在一个类中
2. 重写/被重写的函数参数列表相同，重载/被重载函数列表一定不同
3. 隐藏/被隐藏函数不在一个类中，隐藏/被隐藏函数名相同，参数可同可不同

class StdA\
{
public:
	virtual void funcA(int,int);//被隐藏
	void funcAA(int );//被隐藏
};
class StdB:public StuA
{
public:
	virtual void funcA(int ,char );//
	void funcAA(char);//隐藏funcAA(int)
	void funcB(char,char)//
	void funcB(int,char)//重载
};

1.4 内存分布、存储

内存分为5个区，分别是堆、栈、自由存储区、全局/静态存储区、常量存储区。

1. 栈：在执行程序过程中，局部作用域出现的一些局部变量可以在栈上创建，等脱离该作用域创建的内存被释放。
2. 堆：动态分配，C++：new/delete，C：malloc/free，堆则是 C/C++ 函数库提供的
3. 自由存储区：它是C++基于new操作符的一个概念，凡是通过new操作符申请的内存即为自由存储区
4. 全局/静态存储区：这块内存在程序编译期间已经分配好，在程序整个运行阶段一直存在。全局变量和静态变量
5. 常量存储区：特殊的一块内存，里面存放的是常量，不允许修改

二：代码题

2.1 实现strcpy函数， 将src字符串复制到desc中

//
char* strcpy(char* desc, const char* src)
{
    if (desc == NULL || src == NULL) //内存正常判断
    {
        return NULL;
    }
    char* str = desc;
    while((*str = *src) != '\0')//‘\0'字符串结束标志
    {
        str++;
        src++;
    }
    return desc;
}

2.2 实现strcmp函数， 比较两个字符串

int  intstrcmp2(const char *source,const  char *dest) 
{
	while ((*source != '\0') && (*source == *dest)) 
	{
		source++; 
		dest++;
	}    
	return ((*source) - (*dest)) ? -1 : 0;
}

2.3 求出字符串长度

int strlength(const char* src)
{
    if (src == NULL)
    {
        return 0;
    }
    int n = 0;
    while (*src++ != '\0')
    {
        n++;
    }
    return n;
}

2.4 选择排序

template <typename T>
void SwapVar(T &x,T &y)
{
	T temp = x;
	x = y;
	y = temp;
}
template <typename T>
void SelectionSort(T arr[],int n )
{
	int i,j;
	for(i=0;i<n-1;i++)
	{
		int leastIndex = i;
		for(j=i+1;j<n;j++)
		{
			if(arr[j]<a[leastIndex]
			{
				leastIndex = j;
			}
		}
		SwapVar(arr[i],arr[leastIndex]);
	}
}

2.5 交换排序之冒泡/起泡排序

template <typename T>
void SwapVar(T &x,T &y)
{
	T temp = x;
	x = y;
	y = temp;
}
template <typename T>
void BubbleSort(T arr[],int n )
{
	int i = n-1;
	while(i>0)
	{
		int LastExchangeIndex = 0;
		for(int j=0;j<i;j++)
		{
			if(a[j+1]<a[j])
			{
				SwapVar(a[j],a[j+1]);
				LastExchangeIndex = j;
			}
			i=LastExchangeIdex;
		}
	}
}

2.6 交换两个数

template <typename T>
void myswap(T &x,T &y)
{
	x = x+y;
	y = x-y;
	x = x-y;
}

void myswap(T &x,T &y)
{
	x = x^y;
	y = x^y;
	y = x^y;
}