Hire the Top 3% of 自由c++开发人员

c++是一个强大的, 用于从后端到嵌入式开发的所有内容的通用编程语言, 到桌面应用程序, 到它们运行的操作系统. 它是少数几种经受住时间考验的语言之一, 因此，它当之无愧地受到欢迎和尊重. 但是，尽管ISO c++标准委员会和社区努力使其对程序员更友好, 它仍然可以说是最难掌握的语言之一.

c++的特别之处?

A 伟大的c++开发者 is primarily a 优秀的软件开发人员: someone with a strong problem-solving skillset and abstract thinking, 找到合适的工具和框架的能力, 以及对计算机科学的热情.

There are plenty of interview questions that are language independent and designed to check the engineering prowess of the candidate; on a more basic level, the FizzBuzz问题 在过滤一般编码能力方面是出了名的有效. 但我们目前的重点将非常具体地针对c++.

如果候选人也熟悉应用程序开发 其他语言, there’s an opportunity to make the interview process even more fruitful. In that case, 这前三个问题将开启一场关于不同语言哲学的有趣讨论, 它们的基本结构, 以及由此产生的优点和缺点.

Q: What is RAII and how does it relate to the fact that there is no finally c++异常处理中的关键字?

RAII代表“资源获取即初始化”，是一种特定于c++的资源管理技术. It’s based on the fact that C++ has destructors and a guarantee that they’ll be called for an object when it’s going out of scope, 甚至在异常处理中.

We don’t need finally 来处理我们的资源，因为我们可以用RAII包装它们，并确保析构函数将被调用, thanks to 堆栈解除.

问:什么是常量正确性? 目的(价值)是什么??

const正确性是将变量和成员函数指定为 const 如果它们不打算被修改，则分别修改对象的状态. 最佳实践是使用 const 只要有可能.

const is a contract between the programmer and the compiler—it doesn’t manifest itself in the generated machine code in any way. It’s 优雅的方式 对代码进行文档化，使其更易读，不易出错. 考虑下面的代码片段:

void PaySalary(const EmployeeId employee_id)
{
    Employee& 雇员=公司.FindEmployee (employee_id);
    自动base_salary = employee.GetBaseSalary ();
    Const auto performance_rating = employee.MonthlyPerformance ();
    汽车债务=公司.GetDebt(员工);
    const auto total_pay = CalculateSalary(base_salary, performance_rating, debt);
    company.PaySalary(员工,total_pay);
}

在这个函数中，我们获取一个对象的引用并执行一些进一步的操作. 有人可能想知道这个对象发生了什么——特别是，它可能在什么时候被修改?

The fact that GetBaseSalary and MonthlyPerformance are const 成员函数告诉我们 employee 在这些调用之后不会改变它的状态. GetDebt takes a const Employee&也就是说，它没有被修改过. The PaySalary 然而，函数需要一个 Employee&这就是我们要深入研究的地方.

在设计类时，应该特别注意const的正确性, 因为它包含给将要使用它的开发人员的消息.

更新的c++标准

C++ has picked up an unprecedented pace of development during the last decade. 自2011年以来，我们每三年就有一个新标准:c++ 11、c++ 14、c++ 17和c++ 20. c++ 14是对c++ 11的一个小更新，但其他所有版本都带来了重要的新特性. 了解这些特征显然是必要的, but it’s also important to know their alternatives for the older standards.

Even though the vast majority of the changes in the newer standards are additions—deprecations and removals are very rare—switching a codebase to a new standard is far from easy. 适当的转换，充分利用新特性，将需要大量的重构.

而且仍然有大量的c++ 98和c++ 03代码需要持续的关注和关注. c++ 11和c++ 14也是如此. 除了了解 constexpr if (c++ 17自带), 一个优秀的c++程序员也应该知道如何在使用旧标准的情况下获得同样的结果.

一个有趣的开始讨论的方法是问候选人他们最喜欢的特性是什么。. 强有力的候选人应该能够列出给定标准的最重要的特性, 选择一个最喜欢的, 并给出他们选择的理由. Of course, 没有正确或错误的答案, 但它很快就揭示了候选人对语言的感觉.

问:c++ 11/14引入了几个重要的特性. 你认为哪一个带来了最大的改善，为什么?

The auto 关键词:基于范围 for Loops

The auto 关键字使我们不必在编译器能够推断变量类型时显式地指定它. 这将产生更清晰、更易读和更通用的代码. 基于范围的 for 循环是最常见用例的语法糖.

// c++ 11之前
for (std::vector::const_iterator it = vec.begin(); it != vec.end(); ++it) {

// after C++11
For (const auto .& val : vec) {

Lambda函数

This is a new syntax allowing developers to define function objects in-place.

std:: count_if (vec).begin(), vec.end(), [](const int value) { return value < 10; });

移动语义

这允许我们显式地定义一个对象获得另一个对象的所有权意味着什么. 因此，我们得到了只能移动的类型(std:: unique_ptr, std::thread)，有效的浅拷贝从临时等. This is a pretty big topic nicely covered by a chapter of Scott Meyers’ Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14.

智能指针

c++ 11引入了新的智能指针: unique_ptr, shared_ptr, and weak_ptr. unique_ptr 有效地使 auto_ptr obsolete.

对线程的内置支持

无需纠结于os原生和c风格的库.

问:你觉得c++ 17的哪个特性最有用?为什么?

结构化的绑定

这个特性增加了可读性.

// c++之前
For (const auto .& Name_and_id: name_to_id) {
    const auto& Name = name_and_id.first;
    const auto& Id = name_and_id.second;
 
// after C++17
For (const auto .& [name, id]: name_to_id) {

Compile-time if

With if constexpr，我们可以根据编译时条件启用代码的不同部分. 这使得模板元编程(TMP) enable_if 魔术更容易和更好地实现.

内置文件系统库

就像c++ 11中的线程支持一样, 这个内置库继续减少c++开发人员编写特定于操作系统的代码的需要. 它提供了一个接口来处理文件本身(而不是其内容)和目录, 让开发者复制它们, remove them, 递归地迭代它们, and so on.

Parallel STL

Parallel alternatives of much-used STL algorithms are included with C++17—an important feature ever since multi-core processors have become commonplace even on the desktop.

Q: Which feature of C++20 do you think is a nice addition, and why?

对于开发人员来说，c++ 20至少有两个很有前途的特性.

约束和概念

该特性提供了丰富的新语法，使TMP更加结构化，并且其结构可重用. If used properly, it can make code more readable and better-documented.

Ranges

背后的c++程序员 ranges-v3图书馆 提倡将其包含在c++ 20中. 使用Unix类管道语法, 可组合结构, 惰性范围组合子, 还有其他特点, 这个库的目的是给c++一个现代的, 功能看.

std::vector numbers = …;
对于自动号码:号码
                视图| std::::变换(abs)
                | std::views::filter(is_prime)) {
    …
}
 
//不带范围的选项
For (auto orig_number: numbers) {
    自动编号= abs(orig_number);
    if (!is_prime(数量)){
        continue;
    }
    …
}

在上面的示例中， transform and filter 操作在运行时执行，不影响原容器的内容.

---

Initially, 内定, c++的创造者, 把它命名为“带类的C”,” with the motivation of supporting object-oriented programming (OOP). 对OOP概念和设计模式的一般理解是在语言之外的, 因此，在大多数情况下，检查c++程序员的OOP知识并不需要是特定于c++的. 然而，有一些小的特殊性. 一个很常见的面试问题是:

问:动态多态(虚函数)在c++中是如何工作的?

In C++, dynamic polymorphism is achieved through 虚函数.

class Musician
{
public:
    虚拟void Play() = 0;
};

钢琴家:公共音乐家
{
public:
    虚拟void Play() override {
        //钢琴演奏逻辑
    }
};

class吉他手:公共音乐家
{
public:
    void Play() override {
        //吉他演奏逻辑
    }
};

void AskToPlay(音乐人*音乐人)
{
    musician->Play();
}

多态性(源自希腊语 poly，意为“许多”，以及 morph(意思是“形状”)就是这样 AskToPlay 根据对象的类型以不同的方式运行 musician 指向(它可以是a Pianist or a Guitarist). 问题是c++代码必须被编译成一种机器代码，每种代码都有一组固定的指令, 包括，尤其是 AskToPlay function. Those instructions have to choose where to jump (call) at run-time, to Pianist::Play or 吉他手:玩.

编译器最常用和最有效的方法是使用 虚拟表 (or vtables). 虚表是虚函数的地址数组. 每个类都有自己的虚函数表，该类的每个实例都有一个指向它的指针. 在我们的示例中，调用 Play 实际上变成了对一个函数的调用，该函数驻留在写在虚函数表的第一个条目中的地址上 *musician points to. 如果它被实例化为 Pianist，则其指向虚表的指针将被设置为 Pianist我们最终调用了正确的函数.

---

Another specificity comes from the fact that C++ supports multiple inheritance and there is no formal distinction between an interface and a class. 经典的问题 钻石的问题 这是一个好的开始吗.

作为一种多范式编程语言, c++还支持函数式编程(FP), 在c++ 20标准中引入范围之后，这个问题变得更加重要了. 它使c++更接近另一种语言, more FP-friendly (or FP-focused) languages from the point of view of the expressiveness and readability of the functional code. 一个启动问题的例子是:

问:lambda函数是如何工作的?

编译器生成一个带有 operator() 用lambda的主体, 并使用成员来存储捕获的lambda变量的副本或引用. Here’s an example.

这和另一个关于 虚函数: Either the candidate has looked under the hood and knows exactly how it works, 或者这是一个很好的开始一般性讨论的地方，可以提出一些后续问题，比如 它们通常在什么地方派上用场? and 在lambda函数出现之前，c++编程是什么样的?.

---

模板元编程是c++支持的另一种范式. 它包含了许多有用的特性, which have been accompanied by better alternatives introduced in newer standards. 新功能包括 constexpr and concept让TMP不那么令人费解，但话说回来，仍然有很多产品代码带有谜题. 一个著名的TMP谜题是:

问:如何在编译时计算斐波那契数?

对于较新的标准，它就像拥有一个 constexpr 说明符在递归实现的开头.

conexpr int fibo(int n)
{
    if (n <= 1) {
        return n;
    }
    返回fibo(n - 1) + fibo(n - 2);
}

如果没有这个，它将是:

template 
struct Fibo
{
    static const int value = Fibo::value + Fibo::value;
};

template <>
struct Fibo<1>
{
    Static const int value = 1;
};

template <>
struct Fibo<0>
{
    静态常量int值= 0;
};

---

STL，数据结构和算法

标准模板库(STL)是一个内置在c++中的库. 它在c++中已经存在了很长时间，以至于很难将它从核心语言中分离出来. STL为c++开发人员带来了四种特性:

• Containers—implementations of some fundamental data structures, like vector, list, map, and unordered_map
• 算法——一些基本算法的实现，比如 sort, binary_search, transform, and partition
• Iterators—an abstraction of containers for algorithms to work with
• 函子——一种更加定制算法的方法

STL的设计和理念是独特而广泛的. 任何优秀的c++程序员都必须对STL有很强的了解，但问题是，了解到什么程度? 第一层是所谓的 user level knowledge. 这时应聘者至少知道最流行的容器和算法, 如何以及何时使用它们. 接下来的三个问题是检验这一点的经典问题:

问:两者的区别是什么 list and vector? c++开发者应该如何选择呢?

Both list and vector 顺序容器，但基于不同的数据结构. list 是基于双链表的，而 vector 包含一个原始数组.

优势被他们平分了. vector 连续存储数据的优点是什么, 没有内存开销和固定时间索引访问. In contrast, list 具有恒定时间插入和删除在任何位置，并支持功能，如 splice, merge，以及就地 sort and reverse.

As a result, vector 是更受欢迎，大多数时候是正确的选择. list 在某些极端情况下会是更好的选择吗, 就像处理重拷贝对象一样, 这样开发人员就可以让它们保持有序, 或者通过操纵节点连接从一个容器移动到另一个容器.

问:如何从a中移除所有的_42_s vector? What about a list?

最简单的方法是遍历容器并使用 erase 成员函数，这两个容器都有. 这在a的情况下是完全有效的 list; in fact, its remove 成员函数做的差不多.

但这是有原因的 vector 没有这样的 member function. 这种方法效率很低，因为 vector底层数据结构. 的元素 vector are consecutive in the memory, so erasing an element means shifting all 后面的元素后退一个位置. 这将导致大量额外的复制.

最好的方法是 erase-remove idiom:

vec.擦除(std::删除(vec).begin(), vec.End ()， 42).end());
//初始化- {1,2,42,3,4,42,5,6}
//删除后- {1,2,3,4,5,6， ?, ?, }
//擦除后- {1,2,3,4,5,6}

首先，我们申请 remove 在整个范围内，它不会移除 42它只是把其他的移到最开始，而且是最有效的方式. 而不是移动 6 to the left twice by one position (which would happen if we individually erased 42S)，它只会移动 6 一次，差两个位置. With erase 然后，我们擦掉最后的“浪费”.

This idiom is nicely covered in Item 32 of Scott Meyers’ legendary 有效的STL:提高你对标准模板库使用的50种具体方法.

问:c++中有哪些不同类型的迭代器? 哪些可以使用 std::sort?

STL迭代器有六类: input, output, forward, bidirectional, random access, and contiguous.

迭代器的类别表示它的功能，这些类别是包含的. 这意味着，说的迭代器 set is bidirectional’实际上意味着它也是 forward but neither random access nor contiguous.

Differences of the categories are due to the data structures of the containers. A vector iterator is a random access 1，意思是，不像a set 迭代器，它可以在常数时间内跳转到任意点. std::sort 要求其参数为 random access iterators.

---

这些可以说是STL中最受欢迎的部分, 所以任何有至少一年经验的c++程序员都见过他们并和他们一起工作过. 但这还不够. A high-quality C++ developer has to know not only all the STL containers and how to use them but also the abstract data structures behind them, 各有优缺点.

Also, not only should they know most of the algorithms but also their 渐近的复杂性. 这意味着c++开发人员应该理解, in big-O terms, the performance of standard algorithms and the data structures they use, 以及两者背后的理论. 问题可以非常具体:

STL容器基础

而不是详尽地测试这些知识, an audit-style selection of a few facts—more if needed—should make it clear enough whether the candidate is well-versed enough in these commonly-needed details.

• 一个给定的容器是怎样的.g., vector] implemented?
• [给定容器]的迭代器属于哪一类??
• 一个给定运算的渐近复杂度是多少.g., remove在[给定的容器]上?

vector 使用大小标记将元素存储在基础数组中. When it’s full, a new, 分配更大的存储空间, 元素是从旧存储中复制的, 然后被释放. 它的迭代器是 random access category. ()的渐近复杂度push_back) is 平摊常数时间，索引访问是 constant time, remove is linear.

list implements a doubly linked list, storing pointers to the head and tail nodes. 它的迭代器是 bidirectional. insert()的复杂度push_back and push_front) and remove (pop_back and pop_front) are constant time，而索引访问是 linear.

set and map 是否在平衡二叉搜索树上实现, 更具体地说，是红黑树, 这样就保持了元素的排序. 它们的迭代器是 bidirectional as well. 插入、查找(查找)和删除的复杂性是 logarithmic. 使用迭代器删除元素(erase 成员函数)有 平摊常数时间 complexity.

unordered_set and unordered_map 哈希表的实现是数据结构吗. Usually, it’s an array of so-called buckets, which are simply linked lists. A bucket is chosen for an element (during the insert or lookup) depending on its hash value and the total number of buckets. When there are so many elements in the container that the average bucket size is greater than an implementation-defined threshold (usually 1.0)，则桶的数量增加，并将元素移动到正确的桶中. 这个过程叫做 rehashing，这使得插入变得复杂 平摊常数时间. 查找并删除 constant time complexities.

这些是最基本的容器—必须了解上述细节, 但是否每一个细节都经过测试取决于面试官的直觉.

问:给定算法的渐近复杂度是多少??

一些著名的STL算法的渐近复杂性是:

Algorithm	Complexity
std::sort	O(N log(N))
std:: nth_element	O(N)
std::advance	O(1) for 随机存取迭代器，否则为0 (N)
std:: binary_search	O(log(N)) for 随机存取迭代器，否则为0 (N)
std:: set_intersection	O(N)

或者，用一个简单的问题来解决所有问题:

问:哪些集装箱可以使用 insertion 操作使迭代器失效?

The elegance of this question is that it’s very hard to just remember, and the right answer requires extensive knowledge of underlying data structures of the containers with some logic.

The insertion 操作可能使上的迭代器失效 vector, string, deque, and unordered_set /地图 (在扩展/重新散列的情况下). For list, set, and map但是，由于它们基于节点的数据结构，情况并非如此.

---

It’s standard in many developer interviews to provide a computational problem and expect the candidate to develop an algorithm to solve it. 有很多优秀的c++编程平台，比如LeetCode、HackerRank等. 充满了这样的问题.

These questions are valuable in that they check a lot of things at once. Most interviewers will start with an intentionally underspecified problem statement to test the candidate’s problem-tackling skills and ability to ask the right questions. Then, 候选人必须解决问题, 编写代码, and, 最重要的是, 做一个复杂性分析.

Being good at the latter and having strong knowledge of data structures is quite enough to make wise decisions when using STL containers and algorithms, 还有写新的. 有些人可能会更进一步，看看实际的实现. 每个人都会在某些时候使用STL代码，要么是偶然的，要么是在调试时，要么是自愿的. If the candidate went there and managed to make sense of that gibberish, 这说明了他们的经历, curiosity, 和毅力. For example:

问:哪种排序算法可以 std::sort implement?

The ISO C++ standard doesn’t specify the algorithm; it only sets the requirement of 渐近的复杂性. 然后，选择取决于实现(例如.e.微软vs .微软. GNU.)

它们中的大多数不会只用一个算法来解决，比如 mergesort or quicksort. 一种常见的方法是将它们混合使用，或者根据大小选择一种. 例如，GCC实现了 introsort，这是一个混合的 quicksort and heapsort. It starts with the first and switches to heapsort when the length is less than the implementation-defined threshold.

c++:久经考验，但开发团队必须善于避免它的陷阱

本指南中列出的问题涵盖了c++编程的一些基本方面和一些棘手的方面. 但就像它的可能性一样, 语言隐藏的惊喜是无限的, and that makes it difficult to cover everything about C++ in interviews. Therefore, 评估候选人的能力是必要的, skill set, 通过清晰生动地表达自己的想法，对c++有了深刻的理解.

We hope these questions will help you as a guide in your search for a true high-quality C++ expert in either a full-time or part-time role. 这些罕见的精英可能很难得到, 但对于您的c++编程团队来说，它们将明显地从其他包中脱颖而出.