c++语言基础总结

1.strlen和sizeof区别？

• sizeof是运算符，并不是函数，结果在编译时得到而非运行中获得；strlen是字符处理的库函数。 
• sizeof参数可以是任何数据的类型或者数据（sizeof参数不退化）；strlen的参数只能是字符指针且结尾是'\0'的字符串。

因为sizeof值在编译时确定，所以不能用来得到动态分配（运行时分配）存储空间的大小。

sizeof (type)

sizeof expr

 

2.数组和指针

使用数组的时候编译器会把他转换为指针。

因此在一些情况下数组的操作实际是指针的操作。使用数组作为auto变量的初始值，推断得到类型是指针。

int ia[]={0};

auto ia2(ia); //ia2是int*指针

使用decltype不会发生如此的转换。

数组名和指针（这里为指向数组首元素的指针）区别？

• 二者均可通过增减偏移量来访问数组中的元素。
• 数组名不是真正意义上的指针，可以理解为常指针，所以数组名没有自增、自减等操作。
• 当数组名当做形参传递给调用函数后，就失去了原有特性，退化成一般指针，多了自增、自减操作，但sizeof运算符不能再得到原数组的大小了。

3.结构体内存对齐问题？

结构体内成员按照声明顺序存储，第一个成员地址和整个结构体地址相同。

未特殊说明时，按结构体中size最大的成员对齐（若有double成员），按8字节对齐。

 

4.malloc和new的区别？

• malloc和free是标准库函数，支持覆盖；new和delete是运算符，并且支持重载。
• malloc仅仅分配内存空间，free仅仅回收空间，不具备调用构造函数和析构函数功能，用malloc分配空间存储类的对象存在风险；new和delete除了分配回收功能外，还会调用构造函数和析构函数。
• malloc和free返回的是void类型指针（必须进行类型转换），new和delete返回的是具体类型指针。
• new如果分配失败了会抛出bad_alloc的异常，而malloc失败了会返回NULL。因此对于new，正确的姿势是采用try...catch语法，而malloc则应该判断指针的返回值。为了兼容很多c程序员的习惯，C++也可以采用new nothrow的方法禁止抛出异常而返回NULL；

5.宏定义和函数有何区别？

• 宏在编译时完成替换，之后被替换的文本参与编译，相当于直接插入了代码，运行时不存在函数调用，执行起来更快；函数调用在运行时需要跳转到具体调用函数。
• 宏函数属于在结构中插入代码，没有返回值；函数调用具有返回值。
• 宏函数参数没有类型，不进行类型检查；函数参数具有类型，需要检查类型。
• 宏函数不要在最后加分号。

宏定义和const区别？

• 宏替换发生在编译阶段之前，属于文本插入替换；const作用发生于编译过程中。
• 宏不检查类型；const会检查数据类型。
• 宏定义的数据没有分配内存空间，只是插入替换掉；const定义的变量只是值不能改变，但要分配内存空间。

宏定义和typedef区别？

• 宏主要用于定义常量及书写复杂的内容；typedef主要用于定义类型别名。
• 宏替换发生在编译阶段之前，属于文本插入替换；typedef是编译的一部分。
• 宏不检查类型；typedef会检查数据类型。
• 宏不是语句，不在在最后加分号；typedef是语句，要加分号标识结束。
• 注意对指针的操作，typedef char * p_char和#define p_char char *区别巨大。

宏定义和内联函数(inline)区别？

• 在使用时，宏只做简单字符串替换（编译前）。而内联函数可以进行参数类型检查（编译时），且具有返回值。
• 内联函数本身是函数，强调函数特性，具有重载等功能。
• 内联函数可以作为某个类的成员函数，这样可以使用类的保护成员和私有成员。而当一个表达式涉及到类保护成员或私有成员时，宏就不能实现了。

6.条件编译#ifdef, #else, #endif作用？

• 可以通过加#define，并通过#ifdef来判断，将某些具体模块包括进要编译的内容。
• 用于子程序前加#define DEBUG用于程序调试。
• 应对硬件的设置（机器类型等）。
• 条件编译功能if也可实现，但条件编译可以减少被编译语句，从而减少目标程序大小。

7.volatile有什么作用？

• volatile定义变量的值是易变的，每次用到这个变量的值的时候都要去重新读取这个变量的值，而不是读寄存器内的备份。
• 多线程中被几个任务共享的变量需要定义为volatile类型。

8.区别以下指针类型？

int *p[10]

int (*p)[10]

int *p(int)

int (*p)(int)

• int *p[10]表示指针数组，强调数组概念，是一个数组变量，数组大小为10，数组内每个元素都是指向int类型的指针变量。
• int (*p)[10]表示数组指针，强调是指针，只有一个变量，是指针类型，不过指向的是一个int类型的数组，这个数组大小是10。
• int *p(int)是函数声明，函数名是p，参数是int类型的，返回值是int *类型的。
• int (*p)(int)是函数指针，强调是指针，该指针指向的函数具有int类型参数，并且返回值是int类型的。

9.a和&a有什么区别？

假设数组int a[10];int (*p)[10] = &a;

• a是数组名，是数组首元素地址，+1表示地址值加上一个int类型的大小，如果a的值是0x00000001，加1操作后变为0x00000005。*(a + 1) = a[1]。
• &a是数组的指针，其类型为int (*)[10]（就是前面提到的数组指针），其加1时，系统会认为是数组首地址加上整个数组的偏移（10个int型变量），值为数组a尾元素后一个元素的地址。
• 若(int *)p ，此时输出 *p时，其值为a[0]的值，因为被转为int *类型，解引用时按照int类型大小来读取。

10.野指针是什么？

• 也叫空悬指针，不是指向null的指针，是指向垃圾内存的指针。
• 产生原因及解决办法：
  • 指针变量未及时初始化 => 定义指针变量及时初始化，要么置空。
  • 指针free或delete之后没有及时置空 => 释放操作后立即置空。

11. static_cast、dynamic_cast、const_cast、reinterpret_cast

好的博客参考

• static_cast

static_cast相当于传统的C语言里的强制转换，该运算符把expression转换为new_type类型，用来强迫隐式转换，例如non-const对象转为const对象，编译时检查，用于非多态的转换，可以转换指针及其他，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：

①用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。

进行上行转换（把派生类的指针或引用转换成基类表示）是安全的；

进行下行转换（把基类指针或引用转换成派生类表示）时，由于没有动态类型检查，所以是不安全的。

②用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。

③把空指针转换成目标类型的空指针。

④把任何类型的表达式转换成void类型。

注意：static_cast不能转换掉expression的const、volatile、或者__unaligned属性。

• dynamic_cast

 

type必须是一个类类型，在第一种形式中，type必须是一个有效的指针，在第二种形式中，type必须是一个左值，在第三种形式中，type必须是一个右值。在上面所有形式中，e的类型必须符合以下三个条件中的任何一个：e的类型是是目标类型type的公有派生类、e的类型是目标type的共有基类或者e的类型就是目标type的的类型。如果一条dynamic_cast语句的转换目标是指针类型并且失败了，则结果为0。如果转换目标是引用类型并且失败了，则dynamic_cast运算符将抛出一个std::bad_cast异常(该异常定义在typeinfo标准库头文件中)。e也可以是一个空指针，结果是所需类型的空指针。

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换（cross cast）。

在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；

在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。dynamic_cast是唯一无法由旧式语法执行的动作，也是唯一可能耗费重大运行成本的转型动作。

• const_cast

const_cast，用于修改类型的const或volatile属性。 

该运算符用来修改类型的const(唯一有此能力的C++-style转型操作符)或volatile属性。除了const 或volatile修饰之外， new_type和expression的类型是一样的。

①常量指针被转化成非常量的指针，并且仍然指向原来的对象；

②常量引用被转换成非常量的引用，并且仍然指向原来的对象；

③const_cast一般用于修改底指针。如const char *p形式。

• reinterpret_cast

new_type必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，再把该整数转换成原类型的指针，还可以得到原先的指针值）。

reinterpret_cast意图执行低级转型，实际动作（及结果）可能取决于编辑器，这也就表示它不可移植。

 c++强制转换注意事项

• 新式转换较旧式转换更受欢迎。原因有二，一是新式转型较易辨别，能简化“找出类型系统在哪个地方被破坏”的过程；二是各转型动作的目标愈窄化，编译器愈能诊断出错误的运用。
• 尽量少使用转型操作，尤其是dynamic_cast，耗时较高，会导致性能的下降，尽量使用其他方法替代。

12.C++多态性与虚函数表
基类指针在调用成员函数(虚函数)时，就会去查找该对象的虚函数表。虚函数表的地址在每个对象的首地址。查找该虚函数表中该函数的指针进行调用。
每个对象中保存的只是一个虚函数表的指针，C++内部为每一个类维持一个虚函数表，该类的对象的都指向这同一个虚函数表。
虚函数表中为什么就能准确查找相应的函数指针呢？因为在类设计的时候，虚函数表直接从基类也继承过来，如果覆盖了其中的某个虚函数，那么虚函数表的指针就会被替换，因此可以根据指针准确找到该调用哪个函数。

13.析构函数能抛出异常吗
不能。

C++标准指明析构函数不能、也不应该抛出异常。C++异常处理模型最大的特点和优势就是对C++中的面向对象提供了最强大的无缝支持。那么如果对象在运行期间出现了异常，C++异常处理模型有责任清除那些由于出现异常所导致的已经失效了的对象(也即对象超出了它原来的作用域)，并释放对象原来所分配的资源， 这就是调用这些对象的析构函数来完成释放资源的任务，所以从这个意义上说，析构函数已经变成了异常处理的一部分。

(1) 如果析构函数抛出异常，则异常点之后的程序不会执行，如果析构函数在异常点之后执行了某些必要的动作比如释放某些资源，则这些动作不会执行，会造成诸如资源泄漏的问题。

(2) 通常异常发生时，c++的机制会调用已经构造对象的析构函数来释放资源，此时若析构函数本身也抛出异常，则前一个异常尚未处理，又有新的异常，会造成程序崩溃的问题。
 

14.智能指针是怎么实现的？什么时候改变引用计数？

• 构造函数中计数初始化为1；
• 拷贝构造函数中计数值加1；
• 赋值运算符中，左边的对象引用计数减一，右边的对象引用计数加一；
• 析构函数中引用计数减一；
• 在赋值运算符和析构函数中，如果减一后为0，则调用delete释放对象。

15.手写strcpy,手写memcpy函数,手写strcmp函数

#include<stdio.h>
#include<stdlib.h>
/*
char* strcpy(char* dst, const char* src) {
	assert((dst != NULL) && (src != NULL));
	char* ret = dst;
	int size = strlen(src) + 1;
	if(dst > src && dst < src + len) {
		dst = dst + size - 1;
		src = src + size - 1;
		while(size--) {
			*dst-- = *src--;
		}
	} else {
		while(size--) {
			*dst++ = *src++;
		}
	}
	return ret;
}
*/
void* memcpy(void* dst, const void* src, size_t n){
	if(dst==NULL || src==NULL)return NULL;
	void* ret=dst;
	char* pdst=(char*)dst;
	char* psrc=(char*)src;
	if(pdst>psrc && pdst<psrc+n){
		pdst+=n-1;
		psrc+=n-1;
		while(n--)
			*pdst--=*psrc--;
	}
	else{
		while(n--)
			*pdst++=*psrc++;
	}
	return ret;
}

char* strcat(char* dst,const char* src){
	char* ret=dst;
	while(*dst!='\0')++dst;
	while((*dst++=*src++)!='\0');
	return ret;
}

int strcmp(const char* str1,const char* str2){
	while(*str1==*str2 && *str1!='\0'){
		++str1;
		++str2;
	}
	return *str1-*str2;
}

int main(){
	
	char arr1[100]="abc";
	char arr2[100]="def";
	/*
	char* ret=strcat(arr1,arr2);
	printf("strcat: %s\n",ret);
	int n1=strcmp("123","1234");
	printf("%d\n",n1);
	*/
	char* ret=(char*)memcpy((void*)arr1+3,(void*)arr1,4);
	printf("strcat:%s\n",ret);
}