1. 函数重载

不能仅仅通过返回类型不同来重载函数。

2. 函数指针

什么是回调函数？

当程序跑起来时，一般情况下，应用程序（application program）会时常通过API调用库里所预先备好的函数。但是有些库函数（library function）却要求应用先传给它一个函数，好在合适的时候调用，以完成目标任务。这个被传入的、后又被调用的函数就称为回调函数（callback function）。 作者：no.body 链接：https://www.zhihu.com/question/19801131/answer/27459821 来源：知乎

//回调函数
int DoubleF(int a)
{
	return a * 2;
}

int FourF(int a)
{
	return a * 4;
}

int GetNumber(int k,int (*func)(int))
{
	return (func(k));
}

int main()
{
	int result1 = GetNumber(1,DoubleF);
	int result2 = GetNumber(2, DoubleF);
	std::cout << result1 << std::endl;
	std::cout << result2 << std::endl;
}

输出结果：

指针函数

指针函数，简单的来说，就是一个返回指针的函数，其本质是一个函数，而该函数的返回值是一个指针。 声明格式为：*类型标识符 函数名(参数表)

int * func_sum(int n)

3. 构造函数

使用初始化列表的好处？

1. 类成员中存在非静态常量或者引用类型，只能使用列表初始化

2. 成员变量没有默认初始化函数时，比如自定义的类，同样只能使用列表初始化。

3. 提高效率。

• 为什么成员初始化列表效率更高？

因为对于非内置类型，少了一次调用默认构造函数的过程。

• 初始化列表是成员变量定义的地方，而类里面只是对变量的声明。初始化列表早于为其开辟内存空间。

默认构造函数的作用

• 为什么建议要自定义默认构造函数？

静态成员的初始化问题

4. 顺序容器

array和数组的区别？

array与数组最大的区别是array是一种容器类型，它支持一系列容器操作，但是它和数组更接近，很多通用的容器操作它却不支持，因此在这里和数组来比较。

下面从容器的角度来看array和其他容器的区别。

1. 不支持局部拷贝

例如不允许C c(b, e);//将迭代器b和e之间的元素拷贝到c。不允许用C1={a,b,c...};用列表中的元素替换C1

2.不允许添加或删除元素，因为array是固定大小的。

相比于数组，array可以使用成员函数。其中包括：

1.可以使用拷贝和赋值，只要保证类型一致即可

2.使用swap函数，a.swap(b);或者swap(a,b);交换两者的元素

3.使用正向和反向迭代器

array是数组的升级版，将数组正式纳入到容器的范畴。array在使用和性能上都要强于内置数组，对于一些固定大小的使用场景，可以用array来替代原先数组的工作。

reserve()和resize(), 哪个会初始化vector?

从两个函数的用途可以发现，容器调用resize()函数后，所有的空间都已经初始化了，所以可以直接访问。

而reserve()函数预分配出的空间没有被初始化，所以不可访问。

写一个自己的string？

https://www.cnblogs.com/chengxuyuancc/p/3233124.html

1. 头文件

class String
{
public:
    String();
    String(const char *);
    String(const String &);
    String(String &&); //新加的move构造函数

    ~String();

    String& operator=(const char *);
    String& operator=(const String &);

    bool operator==(const char *);
    bool operator==(const String &);

    char &operator[](int);

    String operator+(const char *);
    String operator+(const char);
    String operator+(const String &);

    String &operator +=(const char *);
    String &operator +=(const char);
    String &operator +=(const String &);

    int size(){return _size;}
    char *c_str(){return _string;}

    friend istream &operator>>(istream &cin, String &str);
private:
    int _size;
    char *_string;
};

2. 源文件

String::String(const char *str)
{
    if (!str)
    {
        _size = 0;
        _string = NULL;
    }
    else
    {
        _size = strlen(str);
        _string = new char[_size + 1];
        strcpy(_string, str);
        _string[_size] = 0;
    }
}

String::~String()
{
    if (_string)
        delete _string;

    cout << "~String() call" << endl;
}

String::String(const String &str)
{
    if (!str._size)
    {
        _size = 0;
        _string = NULL;
    }
    else
    {
        _size = str._size;
        _string = new char[_size + 1];
        strcpy(_string, str._string);
        _string[_size] = 0;
    }

}

String String::operator+(const String &str)
{
    assert(_string && str._string);

    String str_temp(*this);

    str_temp += str;
    return std::move(str_temp);
}

String::String(String && str)
{
    _size = str._size;
    _string = str._string;
    str._string = NULL;
}

istream &operator>>(istream &cin, String &str)
{
    const int limit_string_size = 4096;
    
    str._string = new char[limit_string_size];

    cin >> setw(limit_string_size) >> str._string;
    str._size = strlen(str._string);
    return cin;
}

ostream &operator<<(ostream &cout, String &str)
{
    return cout << str.c_str();
}

如何用队列实现栈？

1.栈实现队列：思路是有两个栈，一个用来放数据（数据栈），一个用来辅助（辅助栈）。数据添加时，会依次压人栈，取数据时肯定会取栈顶元素，但我们想模拟队列的先进先出，所以就得取栈底元素，那么辅助栈就派上用场了，把数据栈的元素依次弹出到辅助栈，但保留最后一个元素，最后数据栈就剩下了最后一个元素，直接把元素返回，这时数据栈已经没有了数据。最后呢，把辅助栈的元素依次压人数据栈，这样，我们成功取到了栈底元素。

2.队列实现栈

思路同上：有数据队列和辅助队列，模拟栈的先进后出，队列是队尾进队头出，也就是说每次取值要取队列的队尾元素，数据队列出队到辅助队列，留下最后一个元素返回，辅助队列再把元素出队到数据队列