cpp-面试题

发表于 分类于 阅读次数： 本文字数： 4.3k 阅读时长 ≈ 4 分钟

C++ 11 relative

move semantic

为了提高效率，避免复制构造函数的拷贝动作。

perfect forwarding

会保留参数的左右值类型

template <typename T>
void func(T t) {
    cout << "in func " << endl;
}

template <typename T>
void relay(T&& t) {
    cout << "in relay " << endl;
    func(std::forward<T>(t));
}

smart pointer

  • unique_ptr: 如果内存资源的所有权不需要共享，就应当使用这个（它没有拷贝构造函数），但是它可以转让给另一个unique_ptr（存在move构造函数）。
  • shared_ptr: 如果内存资源需要共享，那么使用这个（所以叫这个名字）。
  • weak_ptr: 持有被shared_ptr所管理对象的引用，但是不会改变引用计数值。它被用来打破依赖循环（想象在一个tree结构中，父节点通过一个共享所有权的引用(chared_ptr)引用子节点，同时子节点又必须持有父节点的引用。如果这第二个引用也共享所有权，就会导致一个循环，最终两个节点内存都无法释放）。

显示地使用shared_ptr构造函数来构造则至少需要两次内存分配。除了会产生额外的开销，还可能会导致内存泄漏。
使用make_shared就不会有这个问题了

// 下面两个是等价的
std::shared_ptr<int> p1(new int(42));
auto p3 = std::make_shared<int>(42);

Lambda

nullptr

关键字 nullptr 是 std::nullptr_t 类型的值，用来指代空指针。nullptr 和任何指针类型以及类成员指针类型的空值之间可以发生隐式类型转换，同样也可以隐式转换为 bool 型（取值为 false）。但是不存在到整形的隐式类型转换。

NULL 的定义是

#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
比如f（char*）和f（int），参数传NULL的话到底该调用哪个？事实上，在VS下测试这样的函数重载会优先调用f（int），但是f（char *）也是正确的，因此C++引入nullptr来避免这个问题。

range for

int arr[] = {1,2,3,4,5};
for(int& e : arr)
{
  e = e*e;
}

设计模式

  • 单例模式
    // 懒汉式单例模式
    class Singleton
    {
    private:
    	Singleton() { }
    	static Singleton * pInstance;
    public:
    	static Singleton * GetInstance()
    	{
    		if (pInstance == nullptr)
    			pInstance = new Singleton();
    		return pInstance;
    	}
    };

    // 线程安全的单例模式
    class Singleton
    {
    private:
    	Singleton() { }
    	~Singleton() { }
    	Singleton(const Singleton &);
    	Singleton & operator = (const Singleton &);
    public:
    	static Singleton & GetInstance()
    	{
    		static Singleton instance;
    		return instance;
    	}
    };

const

作用：

  • 修饰变量，说明该变量不可以被改变；
  • 修饰指针，分为指向常量的指针和指针常量；
    常量指针：只能读取内存数据，不能修改内存数据的指针。
    指针常量：是指指针所指向的位置不能改变，即指针本身是一个常量，但是指针所指向的内容可以改变。
  • 常量引用，经常用于形参类型，即避免了拷贝，又避免了函数对值的修改；
  • 修饰成员函数，说明该成员函数内不能修改成员变量。
//定义变量
int a=1;
//定义常量
const int b=2;
//定义常量指针
const int *ptr1=&a;
//定义指针常量，必须赋值
int* const ptr2=&a;

//错误，不能把常量的地址赋给指针变量
int *ptr3=&b;
//正确，可以把常量的地址赋给常量指针
const int* ptr4=&b;
//错误，间接引用常量指针不可以修改内存中的数据
*ptr1=3;
// 类
class A
{
private:
    const int a;                // 常对象成员，只能在初始化列表赋值

public:
    // 构造函数
    A() { };
    A(int x) : a(x) { };        // 初始化列表

    // const可用于对重载函数的区分
    int getValue();             // 普通成员函数
    int getValue() const;       // 常成员函数，不得修改类中的任何数据成员的值
};

void function()
{
    // 对象
    A b;                        // 普通对象，可以调用全部成员函数
    const A a;                  // 常对象，只能调用常成员函数、更新常成员变量
    const A *p = &a;            // 常指针
    const A &q = a;             // 常引用

    // 指针
    char greeting[] = "Hello";
    char* p1 = greeting;                // 指针变量，指向字符数组变量
    const char* p2 = greeting;          // 指针变量，指向字符数组常量
    char* const p3 = greeting;          // 常指针，指向字符数组变量
    const char* const p4 = greeting;    // 常指针，指向字符数组常量
}

// 函数
void function1(const int Var);           // 传递过来的参数在函数内不可变
void function2(const char* Var);         // 参数指针所指内容为常量
void function3(char* const Var);         // 参数指针为常指针
void function4(const int& Var);          // 引用参数在函数内为常量

// 函数返回值
const int function5();      // 返回一个常数
const int* function6();     // 返回一个指向常量的指针变量，使用：const int *p = function6();
int* const function7();     // 返回一个指向变量的常指针，使用：int* const p = function7();

inline 函数

编译器对 inline 函数的处理步骤：

  • 将 inline 函数体复制到 inline 函数调用点处；
  • 为所用 inline 函数中的局部变量分配内存空间；
  • 将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；
  • 如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用 GOTO）。

优点

  • 内联函数同宏函数一样将在被调用处进行代码展开，省去了参数压栈、栈帧开辟与回收，结果返回等，从而提高程序运行速度。

  • 内联函数相比宏函数来说，在代码展开时，会做安全检查或自动类型转换（同普通函数），而宏定义则不会。

  • 在类中声明同时定义的成员函数，自动转化为内联函数，因此内联函数可以访问类的成员变量，宏定义则不能。

  • 内联函数在运行时可调试，而宏定义不可以。
    缺点

  • 代码膨胀。内联是以代码膨胀（复制）为代价，消除函数调用带来的开销。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。

  • inline 函数无法随着函数库升级而升级。inline函数的改变需要重新编译，不像 non-inline 可以直接链接。

  • 是否内联，程序员不可控。内联函数只是对编译器的建议，是否对函数内联，决定权在于编译器。

虚函数（virtual）可以是内联函数（inline）吗？

  • 虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。
  • 内联是在编译器建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。
  • inline virtual 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 Base::who()），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。
#include <iostream>  
using namespace std;
class Base
{
public:
	inline virtual void who()
	{
		cout << "I am Base\n";
	}
	virtual ~Base() {}
};
class Derived : public Base
{
public:
	inline void who()  // 不写inline时隐式内联
	{
		cout << "I am Derived\n";
	}
};

int main()
{
	// 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。
	Base b;
	b.who();

	// 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。  
	Base *ptr = new Derived();
	ptr->who();

	// 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。
	delete ptr;
	ptr = nullptr;

	system("pause");
	return 0;
}

数据库相关

什么情况下设置了索引但无法使用

  • LIKE语句，模糊匹配
  • OR语句
  • 数据类型出现隐式转化（如varchar不加单引号的话可能会自动转换为int型）