C++ 面向对象面试题, C++

Step 1

Q:: 什么是面向对象编程？

A:: 面向对象编程（OOP）是一种编程范式，它使用对象及其交互来设计应用程序和计算机程序。其核心概念包括类、对象、继承、多态、封装和抽象。

Step 2

Q:: C++中的类和对象有什么区别？

A:: 类是一个模板，它定义了对象的属性和行为。对象是类的实例，是实际存在的实体，可以访问类中的属性和方法。

Step 3

Q:: 请解释C++中的继承。

A:: 继承是面向对象编程中的一个机制，通过它，一个类可以继承另一个类的属性和方法。C++支持多继承，即一个类可以继承多个基类。

Step 4

Q:: 什么是多态？

A:: 多态性是指同一接口可以有不同实现的能力。C++支持编译时多态（函数重载和运算符重载）和运行时多态（通过虚函数实现）。

Step 5

Q:: C++中的虚函数是什么？

A:: 虚函数是一种可以在子类中重写的成员函数。通过在基类中声明为虚函数，可以在运行时根据对象的实际类型调用相应的重写函数。

Step 6

Q:: 什么是封装？

A:: 封装是将对象的属性和方法结合在一起，并将一些细节信息隐藏起来，只暴露必要的接口给外部使用。这样可以保护对象的内部状态，并提高代码的可维护性和可扩展性。

Step 7

Q:: 请解释抽象类和接口的区别。

A:: 抽象类是不能实例化的类，它可以包含抽象方法（没有实现的方法）和具体方法（有实现的方法）。接口是一种特殊的抽象类，所有方法都是纯虚函数，且接口不能包含数据成员。

Step 8

Q:: C++如何实现接口？

A:: C++通过纯虚函数实现接口，即在类中声明纯虚函数（使用 = 0 语法），然后在派生类中实现这些纯虚函数。

Step 1

Q:: 什么是C++ STL（标准模板库），它的主要组件有哪些？

A:: C++ 标准模板库 (STL) 是一个集合的模板类和函数，用于解决常见数据结构和算法问题。STL 主要包含四大组件：容器 (Containers)、算法 (Algorithms)、迭代器 (Iterators)、函数对象 (Functors)。容器用于存储数据，算法用于处理数据，迭代器用于访问数据，而函数对象则允许算法被灵活地应用。

Step 2

Q:: C++ STL中的容器类型有哪些，它们各自的特点是什么？

A:: C++ STL 提供了多种容器，主要包括序列式容器（如vector、list、deque），关联式容器（如set、map、multiset、multimap），以及无序容器（如unordered_set、unordered_map）。序列式容器强调顺序存储，关联式容器强调键值对存储并具备快速查找特性，无序容器使用哈希表进行存储。

Step 3

Q:: C++中的迭代器（Iterator）是什么，它有什么作用？

A:: 迭代器是 STL 提供的一种对象，用于在容器中进行遍历操作。它们本质上是指针，但更为抽象和通用，可以统一处理不同类型的容器。常见的迭代器类型包括输入迭代器、输出迭代器、前向迭代器、双向迭代器和随机访问迭代器。

Step 4

Q:: STL中的算法与容器是如何协同工作的？

A:: STL 的设计思想是算法和容器分离，这意味着算法独立于容器而存在。算法通过迭代器访问容器中的元素，而不是直接操作容器。这样，算法可以适用于任何类型的容器，只要该容器提供兼容的迭代器类型。

Step 5

Q:: 如何选择合适的 STL 容器？

A:: 选择 STL 容器通常需要根据数据的访问模式和性能需求来进行。如果需要频繁的随机访问，vector 是较好的选择；如果需要频繁的插入和删除操作，list 或 deque 更合适；如果需要快速查找特定元素，map、set 或其无序版本可能是最佳选择。

Step 6

Q:: STL中的vector和list有什么区别？什么时候该使用它们？

A:: vector 和 list 都是序列式容器，但它们的内部实现和性能特点不同。vector 是动态数组，支持高效的随机访问，但在插入和删除元素时可能涉及大量的移动操作。list 是双向链表，支持高效的插入和删除操作，但随机访问较慢。一般来说，当需要快速随机访问时选择vector，当需要频繁插入或删除时选择list。

Step 7

Q:: 如何避免或减少C++ STL中的性能开销？

A:: 在使用 STL 时，为了避免性能开销，可以考虑以下几点：选择合适的容器，避免不必要的拷贝操作，使用move语义减少资源开销，合理使用算法和迭代器，以及尽量避免不必要的内存分配（如使用reserve方法预分配内存）。

Step 8

Q:: C++ STL中有没有线程安全的问题？如何处理？

A:: C++ STL 中的大多数容器和算法不是线程安全的。如果多个线程同时读写同一个容器，可能会导致未定义行为。要确保线程安全，可以使用互斥锁（如std::mutex）来保护对容器的访问，或者使用线程安全的数据结构（如std::atomic, std::shared_mutex等）。

Step 9

Q:: STL中有哪些常见的算法？它们的作用是什么？

A:: STL 中包含一系列通用算法，如排序算法 (std::sort)，查找算法 (std::find, std::binary_search)，修改算法 (std::copy, std::replace)，数值算法 (std::accumulate, std::inner_product) 等。这些算法大大简化了常见的操作，并且可以应用于任何容器。

Step 10

Q:: 在STL中如何自定义比较器来实现排序或查找？

A:: 在 STL 中，许多算法和容器（如 sort 和 map）可以接受一个自定义的比较器（通常是一个函数或函数对象），用于定义元素之间的顺序关系。例如，通过提供一个自定义的比较器，您可以按照特定的规则对容器进行排序或查找元素。

Step 1

Q:: What are the major new features introduced in C++11?

A:: C++11 introduced several major new features including but not limited to: auto keyword for type inference, range-based for loops, lambda expressions, nullptr, strongly-typed enumerations, the nullptr keyword, smart pointers (std::shared_ptr, std::unique_ptr), move semantics, rvalue references, and the introduction of the std::thread library for multi-threading.

Step 2

Q:: Explain what move semantics are and how they improve performance in C++11.

A:: Move semantics are a feature of C++11 that allow resources to be moved rather than copied, which can improve performance. When a resource (such as memory or file handles) is 'moved,' the original object is left in an invalid but safely destructible state, while the new object takes ownership of the resource. This is particularly useful in avoiding unnecessary deep copies, especially in scenarios involving temporary objects or return values from functions.

Step 3

Q:: What is the significance of the auto keyword in C++11?

A:: The auto keyword in C++11 allows the compiler to automatically deduce the type of a variable at compile time. This can simplify code and make it easier to write and maintain, especially when dealing with complex types or templates. For instance, instead of explicitly writing out a long type name, you can use auto to let the compiler determine the correct type for you.

Step 4

Q:: Can you explain what lambda expressions are in C++ and provide an example of their use?

A:: Lambda expressions in C++ are anonymous function objects (also called closures) that can capture variables from the surrounding context. They are defined using the [] syntax, followed by an optional parameter list, a return type, and a function body. For example: auto add = [](int a, int b) { return a + b; }; creates a lambda that adds two integers. Lambdas are often used in algorithms, event handling, or as a convenient way to define short, on-the-fly functions.

Step 5

Q:: What are smart pointers and how do they differ from raw pointers?

A:: Smart pointers in C++ are objects that manage the lifetime of dynamically allocated memory. Unlike raw pointers, which require explicit deletion to free memory, smart pointers automatically deallocate memory when they go out of scope. C++11 introduces std::shared_ptr, std::unique_ptr, and std::weak_ptr, each with different ownership semantics. std::shared_ptr manages shared ownership, std::unique_ptr ensures unique ownership, and std::weak_ptr is used to prevent dangling pointers in cyclic references.

Step 1

Q:: 什么是RAII(资源获取即初始化)? 它在C++中是如何实现的?

A:: RAII (Resource Acquisition Is Initialization) 是一种管理资源的技术，确保在对象的生命周期中，资源的分配和释放与对象的创建和销毁绑定在一起。在C++中，RAII通常通过构造函数分配资源，析构函数释放资源来实现。例如，std::unique_ptr就是一个典型的RAII对象，它在创建时获取内存，在销毁时自动释放内存。

Step 2

Q:: C++11引入的智能指针有哪些？它们的区别是什么？

A:: C++11引入了三种主要的智能指针：std::unique_ptr, std::shared_ptr, std::weak_ptr。 - std::unique_ptr: 拥有独占所有权，不能被复制，只能移动。 - std::shared_ptr: 允许多个shared_ptr共享同一个对象的所有权，通过引用计数来管理对象的生命周期。 - std::weak_ptr: 是对shared_ptr的弱引用，不影响引用计数，常用于解决shared_ptr的循环引用问题。

Step 3

Q:: C++中的多态是如何实现的？请举例说明。

A:: C++中的多态通过虚函数和继承实现。多态允许使用基类的指针或引用来调用派生类的重写方法。实现方式是通过虚函数表（vtable），每个包含虚函数的类都有一个vtable，存储了该类的虚函数地址。运行时通过vtable的指针（vptr）来调用实际的函数。例如：

 
class Base {
public:
  virtual void show() { std::cout << "Base"; }
};
class Derived : public Base {
public:
  void show() override { std::cout << "Derived"; }
};
Base* b = new Derived();
b->show(); // 输出 "Derived"
 

Step 4

Q:: 什么是模板元编程？在什么场景下适合使用模板元编程？

A:: 模板元编程（Template Metaprogramming，TMP）是利用C++模板在编译时进行计算或逻辑推导的一种编程技术。它允许在编译期生成复杂的代码结构或进行计算，常用于实现泛型算法、类型推导或编译期的优化。适合使用模板元编程的场景包括：编译期常量计算、编译期类型验证、实现不依赖具体数据类型的通用算法等。

Step 5

Q:: C++中的move语义是什么？如何实现一个move构造函数？

A:: C++中的move语义用于在对象从一个上下文移动到另一个上下文时避免不必要的拷贝。move语义通常通过右值引用（T&&）实现，允许对象的资源从一个对象转移到另一个对象，而不是拷贝。在实现move构造函数时，需要在构造函数参数中使用右值引用，并在函数体内使用std::move将资源转移。

 
class MyClass {
  int* data;
public:
  MyClass(MyClass&& other) noexcept : data(other.data) {
    other.data = nullptr;
  }
};
 

Step 1

Q:: 什么是C++中的线程？如何创建一个线程？

A:: 线程是程序执行的基本单位，属于轻量级进程。在C++中，可以使用标准库的std::thread来创建线程。例子如下：

 
#include <iostream>
#include <thread>
void threadFunction() {
    std::cout << "Hello from thread!" << std::endl;
}
int main() {
    std::thread t(threadFunction);
    t.join();
    return 0;
}
 

这里，我们定义了一个线程函数threadFunction并通过std::thread创建并启动该线程，最后通过join将其与主线程合并。

Step 2

Q:: 什么是数据竞争？如何避免数据竞争？

A:: 数据竞争发生在两个或多个线程同时访问同一共享数据，并且至少有一个线程在修改数据，而没有使用适当的同步机制。数据竞争可能导致未定义行为。在C++中，可以使用互斥锁（std::mutex）来避免数据竞争。例如：

 
#include <iostream>
#include <thread>
#include <mutex>
int counter = 0;
std::mutex mtx;
void increment() {
    std::lock_guard<std::mutex> lock(mtx);
    ++counter;
}
int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Counter: " << counter << std::endl;
    return 0;
}
 

在这个例子中，我们使用std::lock_guard确保counter的修改是原子的，以避免数据竞争。

Step 3

Q:: 解释C++中的死锁现象及其如何避免？

A:: 死锁是一种现象，其中两个或多个线程无限期地相互等待对方持有的资源，从而导致程序陷入僵局。避免死锁的策略包括： 1. 避免嵌套锁定：尽量减少锁的使用，尤其是嵌套锁。 2. 锁的顺序：如果多个线程需要多个锁，请确保所有线程以相同的顺序获取锁。 3. 使用std::lock：C++11引入的std::lock可以一次性锁定多个互斥量，避免死锁的可能性。 4. 尝试锁定：使用std::try_lock尝试锁定，如果失败则释放已经获得的锁并重试。

Step 4

Q:: C++11标准中的std::async和std::future是什么？如何使用它们实现异步操作？

A:: std::async是C++11标准中引入的，用于异步执行任务。std::future是一个与std::async配合使用的模板类，用来获取异步任务的结果。示例代码如下：

 
#include <iostream>
#include <future>
int task() {
    return 42;
}
int main() {
    std::future<int> result = std::async(std::launch::async, task);
    std::cout << "Result: " << result.get() << std::endl;
    return 0;
}
 

在这个例子中，task函数会异步执行，而result.get()则会阻塞直到任务完成并返回结果。std::async使得我们能够轻松实现并发执行和异步操作。

Step 5

Q:: 什么是线程局部存储（Thread Local Storage）？在C++中如何实现？

A:: 线程局部存储（TLS）允许每个线程拥有其自己的独立存储空间。C++11通过thread_local关键字支持TLS。例如：

 
#include <iostream>
#include <thread>
thread_local int counter = 0;
void increment() {
    ++counter;
    std::cout << "Counter: " << counter << std::endl;
}
int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    return 0;
}
 

在这个例子中，每个线程都有一个独立的counter变量，因此t1和t2中的counter互不影响。

Step 1

Q:: What is the difference between a pointer and a reference in C++?

A:: A pointer is a variable that holds the memory address of another variable. It can be reassigned and can point to NULL. A reference, on the other hand, is an alias for another variable. Once a reference is bound to a variable, it cannot be changed to refer to another variable. Pointers allow for pointer arithmetic and can be incremented or decremented, while references cannot. References are generally safer to use as they are less error-prone.

Step 2

Q:: Explain the concept of RAII (Resource Acquisition Is Initialization) in C++.

A:: RAII is a programming idiom in C++ where resource allocation and deallocation are tied to object lifetime. When an object is created, it acquires resources (like memory, file handles, etc.), and when the object goes out of scope, its destructor automatically releases those resources. This ensures that resources are properly cleaned up, preventing leaks and other resource management issues. RAII is particularly useful in the context of exception handling, as it ensures that resources are freed even if an exception occurs.

Step 3

Q:: What is the difference between ‘new’ and ‘malloc’ in C++?

A:: The 'new' operator in C++ not only allocates memory like 'malloc' but also calls the constructor of the object, initializing it. 'malloc' only allocates raw memory and does not invoke any constructors. Additionally, memory allocated with 'new' should be freed using 'delete', whereas memory allocated with 'malloc' should be freed using 'free'. Using 'delete' on memory allocated with 'malloc' or vice versa leads to undefined behavior.

Step 4

Q:: What is a virtual function and why is it important?

A:: A virtual function is a function in a base class that can be overridden in derived classes. It allows for dynamic (run-time) polymorphism, enabling the appropriate function for an object to be called based on its actual derived type, rather than the type of the pointer/reference pointing to it. This is crucial in scenarios where the exact type of an object isn’t known until runtime, allowing for flexible and reusable code.

Step 5

Q:: Can you explain what a smart pointer is and why it is used?

A:: A smart pointer is an object that wraps a raw pointer to manage the lifetime of the dynamically allocated memory to which the raw pointer points. It automatically deallocates the memory when it is no longer in use, preventing memory leaks. There are different types of smart pointers in C++, such as std::unique_ptr, std::shared_ptr, and std::weak_ptr, each serving different purposes, like unique ownership, shared ownership, and preventing dangling references, respectively.