当前位置：首页 > news >正文

面向对象八股文（长期跟新_整理收集_排版未优化_day03_20个）

news 2025/8/12 9:24:58

1、面向对象八股文（长期跟新_整理收集_排版已优化_day01_20个)
2、面向对象八股文（长期跟新_整理收集_排版未优化_day02_20个）
3、面向对象八股文（长期跟新_整理收集_排版未优化_day03_20个）

41、C++中如何实现多继承？

在C++中，多继承是指一个类可以从多个基类继承。与单继承不同，多继承允许一个类继承多个基类的成员（包括成员函数和数据成员）。在C++中实现多继承非常简单，只需要在类的定义中用逗号分隔多个基类即可。

示例代码

以下是一个简单的多继承示例，展示了如何在C++中实现多继承：

#include <iostream>// 定义基类A
class A {
public:void showA() {std::cout << "Class A function." << std::endl;}
};// 定义基类B
class B {
public:void showB() {std::cout << "Class B function." << std::endl;}
};// 定义派生类C，继承自A和B
class C : public A, public B {
public:void showC() {std::cout << "Class C function." << std::endl;}
};int main() {C obj;obj.showA();  // 调用A类的方法obj.showB();  // 调用B类的方法obj.showC();  // 调用C类的方法return 0;
}

代码解释

定义基类A和B：A 和 B 是两个基类，分别有各自的成员函数 showA() 和 showB()。
定义派生类C：类 C 同时继承自 A 和 B，这就是多继承的实现方式。在类 C 的定义中，通过使用冒号 : 和逗号 , 分隔基类来表示从多个基类继承。
创建对象并调用函数：在 main 函数中，创建了类 C 的对象 obj，并分别调用了从基类 A 和 B 继承的方法 showA() 和 showB()，以及类 C 自己的方法 showC()。

注意事项

菱形继承问题：多继承可能会引发菱形继承问题（也叫“钻石问题”），即如果两个基类都有一个相同的基类，那么派生类会继承两份相同的基类成员。解决方法是使用虚继承（virtual inheritance）。
命名冲突：如果不同基类中有同名的成员（函数或数据成员），那么在派生类中会发生命名冲突。这种情况下，需要使用类名来指定调用哪个基类的成员。

通过上述方式，我们可以在C++中灵活地使用多继承来复用代码和实现复杂的类层次结构，但也要注意可能带来的复杂性和潜在问题。

42、解释一下C++中的静态成员和静态函数。

1、静态成员与静态函数

在 C++ 中，静态成员（static member）和静态函数（static function）是与类相关联的特殊成员，它们与类的实例独立，而与特定的对象无关。以下是它们的解释：

2. 静态成员：

①静态成员是属于类本身的成员，而不是类的实例。也就是说，无论创建了多少个类的实例，静态成员的内存只分配一次。
② 静态成员可以是数据成员或函数成员。
③ 静态数据成员在类内声明时需要加上 static 关键字，并且通常在类外初始化。它们可以被所有该类的对象共享，并且可以通过类名直接访问。
④静态函数成员也需要使用 static 关键字进行声明，它们不需要通过对象来调用，而是可以通过类名直接调用。静态函数成员通常用于执行与类相关的操作，而不是与特定对象相关的操作。

3. 静态函数：

①静态函数成员是类的成员函数，它们不操作特定的对象实例，而是与类本身相关联。因此，它们不具有 this 指针，不能访问非静态成员变量。
②静态函数成员在类内声明时需要加上 static 关键字，并且在类外定义时也要加上 static 关键字。
③静态函数成员可以通过类名直接调用，无需创建类的实例。

下面是一个简单的示例，演示了静态成员和静态函数的用法：

#include <iostream>class MyClass {
public:static int staticVar; // 静态数据成员static void staticFunction() { // 静态函数成员std::cout << "Static function called" << std::endl;}
};int MyClass::staticVar = 0; // 静态数据成员初始化int main() {// 通过类名直接访问静态数据成员和调用静态函数成员std::cout << "Static variable: " << MyClass::staticVar << std::endl;MyClass::staticFunction();// 也可以通过对象访问静态成员，但不推荐MyClass obj;std::cout << "Static variable (via object): " << obj.staticVar << std::endl;obj.staticFunction();return 0;
}

在这个示例中，静态数据成员 staticVar 被所有的 MyClass 对象共享，而静态函数成员 staticFunction 可以通过类名直接调用。

4、使用场景和注意事项：

①静态成员的共享性：静态成员适用于所有类的实例共享同一份数据或功能的情况。例如，可以使用静态数据成员来统计类的实例数量。
②静态成员的生命周期：静态数据成员和静态成员函数的生命周期与程序的生命周期相同，它们在程序启动时分配内存，在程序结束时释放内存。
③访问权限：静态成员函数可以访问静态和非静态成员，但非静态成员函数不能直接访问静态成员。
静态数据成员初始化：静态数据成员的初始化通常需要在类的实现文件中进行，避免在头文件中重复定义。

// MyClass.h
class MyClass {
public:static int staticVariable;  // 静态数据成员声明
};// MyClass.cpp
int MyClass::staticVariable = 0;  // 静态数据成员定义和初始化

总体而言，静态成员和静态函数是与类本身关联的，而不是与类的实例关联的。它们提供了一种在类层面上组织和管理共享数据和功能的方法。

3、静态成员可以被修改吗

静态数据成员可以被修改，但需要注意几点：

访问权限：静态数据成员的访问权限由其所属类的访问控制修饰符控制。如果静态数据成员被声明为公有（public），则可以通过类名或对象名直接访问并修改；如果被声明为私有（private）或受保护（protected），则只能在类的成员函数中访问和修改。
直接访问：静态数据成员可以通过类名直接访问，也可以通过对象名访问。然而，为了避免混淆，通常建议使用类名来访问和修改静态数据成员。
初始化：静态数据成员在类外部初始化，但可以在类内部声明初始化值。如果在类内部声明初始化值，则初始化的工作将由编译器完成。

下面是一个示例，演示了静态数据成员的修改：

#include <iostream>class MyClass {
public:static int staticVar; // 声明静态数据成员
};// 在类外部初始化静态数据成员
int MyClass::staticVar = 0;int main() {std::cout << "Initial static variable: " << MyClass::staticVar << std::endl;// 直接修改静态数据成员MyClass::staticVar = 10;std::cout << "Modified static variable: " << MyClass::staticVar << std::endl;// 也可以通过对象修改静态数据成员，但不推荐MyClass obj;obj.staticVar = 20;std::cout << "Modified static variable (via object): " << obj.staticVar << std::endl;return 0;
}

在这个示例中，静态数据成员 staticVar 被修改为不同的值，并且可以通过类名或对象名来访问和修改。

43、什么是移动语义（Move Semantics）？它有什么作用？

移动语义（Move Semantics）是 C++11 引入的一项重要特性，它的目标是提高代码的性能和效率，尤其在处理大量数据时。移动语义通过引入右值引用（Rvalue References）和移动构造函数（Move Constructor）、移动赋值运算符（Move Assignment Operator）等机制，实现了在不进行深层复制的情况下，将资源（例如内存）从一个对象转移到另一个对象。

1、右值引用（Rvalue References）：

右值引用的声明：使用 && 表示右值引用，例如 T&& 表示 T 类型的右值引用。

int&& rvalueRef = 42;  // 42 是右值

右值和左值：简而言之，右值是表达式结束后就要销毁的值，而左值是可以取地址的持久值。右值引用通常与临时对象、移动语义等联系在一起。

2、移动构造函数和移动赋值运算符：

①移动构造函数：移动构造函数是一种构造函数，它使用右值引用参数，并从传递的对象中“窃取”资源，而不是进行深层复制。

class MyString {
public:// 移动构造函数MyString(MyString&& other) noexcept {// 窃取资源data_ = other.data_;size_ = other.size_;// 清空原对象other.data_ = nullptr;other.size_ = 0;}
};

3、移动赋值运算符：

类似地，移动赋值运算符用于在赋值时从右值引用参数中“窃取”资源。

class MyString {
public:// 移动赋值运算符MyString& operator=(MyString&& other) noexcept {if (this != &other) {// 释放当前资源delete[] data_;// 窃取资源data_ = other.data_;size_ = other.size_;// 清空原对象other.data_ = nullptr;other.size_ = 0;}return *this;}
};

4、移动语义的作用：

1、避免不必要的深拷贝：在没有移动语义的情况下，对象的复制通常会导致资源（例如动态分配的内存）的深拷贝，造成性能损失。使用移动语义，可以将资源从一个对象转移到另一个对象，避免了深拷贝的开销。

2、提高效率：移动语义使得在传递临时对象时能够高效地将资源转移给接收者，而不是进行昂贵的深拷贝。

3、支持移动语义的容器：标准库中的容器类如 std::vector、std::string 等都已经实现了移动语义，因此在处理大量数据时，可以更高效地进行资源管理。

移动语义是现代 C++ 中的一个关键特性，对于提高性能和资源利用效率非常重要。当你设计自己的类时，考虑实现移动语义，以便更好地支持现代 C++ 的编程范式。

44、解释一下C++11中的智能指针。

C++11引入了智能指针（Smart Pointers），大大简化了内存管理，提高了代码的安全性和可读性。智能指针是一种对象，它在生命周期结束时自动释放动态分配的内存，从而避免了内存泄漏和未定义行为。

C++11中的智能指针类型

C++11引入了三种标准的智能指针类型：

std::unique_ptr：独占所有权的智能指针。
std::shared_ptr：共享所有权的智能指针。
std::weak_ptr：不控制所有权的弱智能指针。

1. `std::unique_ptr`

std::unique_ptr是一种独占所有权的智能指针，这意味着同一时间只能有一个unique_ptr指向某个资源。当unique_ptr被销毁时，它所指向的资源会自动被释放。

特点：

不允许拷贝（拷贝构造函数和拷贝赋值操作符被禁用）。
可以转移所有权（通过std::move）。

示例代码：

#include <iostream>
#include <memory> // 包含智能指针头文件int main() {std::unique_ptr<int> ptr1(new int(10)); // 创建一个unique_ptr，指向整数10std::cout << "ptr1: " << *ptr1 << std::endl;// 转移所有权std::unique_ptr<int> ptr2 = std::move(ptr1);std::cout << "ptr2: " << *ptr2 << std::endl;if (!ptr1) {std::cout << "ptr1 is null after move." << std::endl;}return 0;
}

输出：

ptr1: 10
ptr2: 10
ptr1 is null after move.

解释：

ptr1最初拥有动态分配的整数10的所有权。
使用std::move，将所有权从ptr1转移给ptr2。此后ptr1变为nullptr。

2. `std::shared_ptr`

std::shared_ptr是一种共享所有权的智能指针，它允许多个指针共享同一资源。当最后一个shared_ptr销毁时，资源会被释放。

特点：

允许多个shared_ptr指向同一个对象。
内部维护一个引用计数（reference count），记录有多少个shared_ptr指向同一个对象。
当引用计数变为0时，自动删除所管理的对象。

示例代码：

#include <iostream>
#include <memory>int main() {std::shared_ptr<int> ptr1 = std::make_shared<int>(10); // 创建shared_ptr，指向整数10std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl; // 输出1{std::shared_ptr<int> ptr2 = ptr1; // ptr2 共享 ptr1 的所有权std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl; // 输出2std::cout << "ptr2 use count: " << ptr2.use_count() << std::endl; // 输出2} // 离开作用域，ptr2 被销毁std::cout << "ptr1 use count after ptr2 is destroyed: " << ptr1.use_count() << std::endl; // 输出1return 0;
}

输出：

ptr1 use count: 1
ptr1 use count: 2
ptr2 use count: 2
ptr1 use count after ptr2 is destroyed: 1

解释：

ptr1最初拥有一个整数的所有权，引用计数为1。
ptr2复制了ptr1，现在它们共享所有权，引用计数增加到2。
ptr2离开作用域后，引用计数减回到1。

3. `std::weak_ptr`

std::weak_ptr是一种不拥有对象的智能指针，它只是对std::shared_ptr所管理对象的一个弱引用（不会增加引用计数）。weak_ptr用于解决shared_ptr之间的循环引用问题。

特点：

不影响所引用对象的生命周期。
用于观察一个shared_ptr所指向的对象。
可以通过调用lock()函数将其转化为std::shared_ptr。

示例代码：

#include <iostream>
#include <memory>int main() {std::shared_ptr<int> sharedPtr = std::make_shared<int>(10);std::weak_ptr<int> weakPtr(sharedPtr); // 创建weak_ptr，指向sharedPtrstd::cout << "sharedPtr use count: " << sharedPtr.use_count() << std::endl; // 输出1if (auto lockedPtr = weakPtr.lock()) { // 将weak_ptr转化为shared_ptrstd::cout << "lockedPtr value: " << *lockedPtr << std::endl; // 输出10std::cout << "sharedPtr use count after lock: " << sharedPtr.use_count() << std::endl; // 输出2} // lockedPtr 离开作用域，被销毁std::cout << "sharedPtr use count after lockedPtr is destroyed: " << sharedPtr.use_count() << std::endl; // 输出1return 0;
}

输出：

sharedPtr use count: 1
lockedPtr value: 10
sharedPtr use count after lock: 2
sharedPtr use count after lockedPtr is destroyed: 1

解释：

weakPtr不增加引用计数，只是观测sharedPtr的对象。
通过weakPtr.lock()，可以安全地获取sharedPtr的对象。

智能指针的优点

自动内存管理：智能指针在不再需要对象时自动释放内存，减少了手动管理的复杂性。
防止内存泄漏：通过严格的所有权规则，智能指针可以有效防止内存泄漏。
提高代码安全性：使用智能指针可以避免空悬指针（dangling pointer）和双重删除（double delete）等问题。
线程安全（部分）：std::shared_ptr的引用计数增加和减少操作是线程安全的。

注意事项

使用std::shared_ptr时要小心循环引用，会导致内存泄漏。可以通过std::weak_ptr解决这个问题。
std::unique_ptr和std::shared_ptr的默认删除器会调用delete，如果需要特殊的删除行为，可以指定自定义删除器。

47、什么是模板元编程（Template Metaprogramming）？

模板元编程（Template Metaprogramming，TMP）是一种在编译期间进行计算和代码生成的技术，利用C++模板系统中的模板特性。通过模板元编程，可以在编译时执行计算，生成复杂的代码结构，实现一些在运行时难以完成或者不适合在运行时完成的操作。

模板元编程的核心思想是利用模板的递归实例化和特化，通过模板参数、类型、常量表达式等来进行计算和代码生成。在模板元编程中，程序员可以使用模板和元编程技术，将计算和操作推迟到编译时。

模板元编程的一些常见特点和应用包括：

1、递归： TMP 中经常使用递归来实现计算和代码生成。

2、模板特化：通过特化模板，可以在特定条件下提供不同的实现。

3、常量表达式： C++11 引入的常量表达式和constexpr函数提供了在编译时进行计算的能力，与TMP结合使用可以实现更强大的元编程。

4、编译时计算： TMP 可以在编译时执行各种计算，例如计算阶乘、斐波那契数列、判断质数等。

5、类型计算： TMP 可以进行类型的计算和推导，例如元组的类型计算、类型列表的操作等。

模板元编程在一些库和框架中得到了广泛应用，例如在STL中使用模板元编程来实现类型转换、条件选择等功能。然而，模板元编程的语法和技术相对较复杂，需要对C++模板系统有深入的理解，因此通常在编写库、框架或者一些需要高度泛化的代码时才使用。

48、C++中如何处理线程和并发操作？

在C++中，线程和并发操作可以通过标准库中的、、<condition_variable> 等头文件提供的工具来实现。以下是一些常见的线程和并发操作的处理方式：

1、创建和管理线程：

1、使用头文件中的 std::thread 类可以创建和管理线程。

#include <iostream>
#include <thread>void myFunction() {std::cout << "Hello from thread!" << std::endl;
}int main() {// 创建线程并启动std::thread myThread(myFunction);// 主线程继续执行其他操作// 等待子线程完成myThread.join();return 0;
}

2、互斥锁和临界区：

使用头文件中的 std::mutex 类可以创建互斥锁，保护共享资源，防止多个线程同时访问。

#include <iostream>
#include <mutex>
#include <thread>std::mutex myMutex;// 将互斥锁资源的访问封装在函数之中
void sharedResourceOperation() {std::lock_guard<std::mutex> lock(myMutex);// 访问共享资源的操作
}int main() {std::thread thread1(sharedResourceOperation);std::thread thread2(sharedResourceOperation);// 等待两个线程执行thread1.join();thread2.join();return 0;
}

3、条件变量：

使用 <condition_variable> 头文件中的 std::condition_variable 类可以实现线程之间的同步和通信。

#include <iostream>
#include <mutex>
#include <condition_variable>
#include <thread>std::mutex myMutex;
std::condition_variable myCondition;bool dataReady = false;void producer() {// 产生数据{std::lock_guard<std::mutex> lock(myMutex);dataReady = true;}// 通知等待的线程myCondition.notify_one();
}void consumer() {std::unique_lock<std::mutex> lock(myMutex);// 等待数据就绪myCondition.wait(lock, [] { return dataReady; });// 处理数据std::cout << "Data is ready!" << std::endl;
}int main() {std::thread producerThread(producer);std::thread consumerThread(consumer);producerThread.join();consumerThread.join();return 0;
}

4、原子操作：

使用头文件中的原子类型，如 std::atomic，可以进行原子操作，避免多个线程同时访问导致的数据竞争问题。

#include <iostream>
#include <atomic>
#include <thread>std::atomic<int> counter(0);void incrementCounter() {for (int i = 0; i < 1000000; ++i) {counter.fetch_add(1, std::memory_order_relaxed);}
}int main() {std::thread thread1(incrementCounter);std::thread thread2(incrementCounter);thread1.join();thread2.join();std::cout << "Counter value: " << counter.load() << std::endl;return 0;
}

以上是一些基本的线程和并发操作的处理方式。在实际应用中，需要根据具体的场景和需求选择适当的同步和并发控制机制。同时，C++11及以后的标准提供了更多的并发工具，包括 std::async、std::future、std::packaged_task 等，用于更方便地处理异步任务和并发编程。

49、解释一下C++中的虚拟继承。

在C++中，虚拟继承（virtual inheritance）是一种用于解决多继承时的菱形继承问题的技术。菱形继承问题发生在一个派生类通过多个路径继承了同一个基类，导致基类中的成员在派生类中出现多次。这种情况下，虚拟继承可以确保基类的成员在派生类中只出现一次。

菱形继承问题

为了更好地理解菱形继承问题，我们先看一个没有虚拟继承的例子：

#include <iostream>class Base {
public:int data;Base() : data(0) {}
};// 派生类A继承自Base
class A : public Base {};// 派生类B继承自Base
class B : public Base {};// 派生类C继承自A和B
class C : public A, public B {};int main() {C obj;obj.A::data = 10;  // 使用A路径访问Base的dataobj.B::data = 20;  // 使用B路径访问Base的data// 打印data值std::cout << "A::data = " << obj.A::data << std::endl;std::cout << "B::data = " << obj.B::data << std::endl;return 0;
}

输出结果：

A::data = 10
B::data = 20

在上面的代码中，类C通过两条路径继承了Base，一条是通过A，另一条是通过B。结果是C拥有了两个Base子对象（一个是A继承来的，另一个是B继承来的），这导致data成员变量在C中有两份。

虚拟继承解决菱形继承问题

通过使用虚拟继承，我们可以确保C类只会继承一个Base子对象。下面是如何使用虚拟继承的代码示例：

#include <iostream>class Base {
public:int data;Base() : data(0) {}
};// 使用虚拟继承
class A : virtual public Base {};class B : virtual public Base {};class C : public A, public B {};int main() {C obj;obj.data = 10;  // data 现在在C中只有一份std::cout << "data = " << obj.data << std::endl;return 0;
}

输出结果：

data = 10

代码解释

虚拟继承的声明：在类A和B的定义中，基类Base前加上了关键字virtual。这告诉编译器A和B是虚拟继承Base类的。
共享基类子对象：通过虚拟继承，A和B都共享同一个Base子对象。因此，派生类C最终只包含一个Base子对象，而不是两个。
解决菱形继承问题：在C类中，Base的成员变量data只有一份，这样就避免了数据的冗余和冲突。

虚拟继承的应用场景

虚拟继承主要用于解决多继承时的菱形继承问题，特别是在多层次继承结构中，确保基类的成员在派生类中不重复出现。使用虚拟继承时需要注意以下几点：

增加开销：虚拟继承需要编译器增加额外的间接访问机制，可能会增加运行时开销。
构造函数复杂性：使用虚拟继承时，基类的构造函数需要在最派生的子类中直接调用，这增加了代码的复杂性。
明确使用场景：虚拟继承适用于需要确保数据唯一性的场景，但并不适合所有多继承情况，需要根据实际需求合理使用。

49、什么是函数对象（Functor）？

函数对象（Functor）是一种行为类似函数的对象，它可以像函数一样被调用。函数对象是一种可调用的实体，通常是一个类的实例，其实例化后可以像函数一样被调用，实现了函数调用运算符 operator()。函数对象在C++中广泛用于STL（标准模板库）和泛型编程。

函数对象有以下几种形式：

1、函数指针：

函数指针是最简单的函数对象形式，它是一个指向函数的指针。

int add(int a, int b) {return a + b;
}int main() {int (*funcPtr)(int, int) = add;int result = funcPtr(3, 4);  // 调用函数指针return 0;
}

2、函数对象类：

函数对象可以是一个类的实例，该类重载了 operator()。

class AddFunctor {
public:int operator()(int a, int b) const {return a + b;}
};int main() {AddFunctor addObj;int result = addObj(3, 4);  // 调用函数对象类return 0;
}

在STL中，比如算法函数 std::sort，可以接受函数对象作为参数，以定义排序的规则。

#include <algorithm>
#include <iostream>
#include <vector>class Compare {
public:bool operator()(int a, int b) const {return a > b;}
};int main() {std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6};std::sort(numbers.begin(), numbers.end(), Compare());for (int num : numbers) {std::cout << num << " ";}return 0;
}

3、Lambda 表达式：

C++11 引入了 Lambda 表达式，它是一种方便创建匿名函数对象的方式。

int main() {auto add = [](int a, int b) { return a + b; };int result = add(3, 4);  // 调用 Lambda 表达式return 0;
}

函数对象的使用使得在泛型编程中更加灵活，可以通过传递不同的函数对象来改变算法的行为，同时它可以包含状态，实现更复杂的逻辑。函数对象在STL中的排序、查找等算法中经常被使用。

50、解释一下C++中的类型转换。

C++中的类型转换指的是将一个数据的类型转换为另一个数据类型的过程。C++提供了多种类型转换的方式，主要包括以下几种：

1、隐式类型转换（Implicit Conversion）：

隐式类型转换是编译器自动执行的类型转换，通常是在不同类型之间的运算或赋值操作时发生。这种转换是由编译器根据上下文进行的，不需要程序员明确指定。

int integerNumber = 42;
double doubleNumber = integerNumber;  // 隐式类型转换

在某些情况下，隐式类型转换可能导致精度损失或不可预料的结果，因此需要注意。

2、显式类型转换（Explicit Conversion）：

显式类型转换是由程序员明确指定的类型转换方式。C++提供了以下几种显式类型转换：
使用 C 风格的类型转换：

3、C 风格的强制类型转换：

int integerNumber = 42;
double doubleNumber = (double)integerNumber;  // C 风格的强制类型转换

函数风格的强制类型转换：

C++引入了四个用于强制类型转换的关键字，分别是：

static_cast，使用 C++ 中的 static_cast

dynamic_cast，使用 C++ 中的 dynamic_cast（通常用于具有继承关系的类型之间的转换）

const_cast，使用 C++ 中的 const_cast（用于移除对象的 const 属性或者将对象的 const 属性加回去）

reinterpret_cast，使用 C++ 中的 reinterpret_cast（用于执行底层类型之间的转换）：

int integerNumber = 42;
double doubleNumber = static_cast<double>(integerNumber);  // static_cast 强制类型转换

这些强制类型转换提供了更丰富的语义，并且在一定程度上提供了类型安全性。

4、C++11 中的类型推导（Type Inference）：

C++11引入了 auto 和 decltype 关键字，用于在编译期间自动推导表达式的类型，从而达到类型转换的目的。

int integerNumber = 42;
auto convertedNumber = static_cast<double>(integerNumber);  // 类型推导

auto 根据右值表达式的类型自动推导出变量的类型，而 decltype 可以根据表达式的类型声明一个新的变量。

总体而言，类型转换在编程中是一种常见的操作，但需要谨慎使用，以确保不会导致不可预料的结果或安全性问题。最好使用更安全和明确的转换方式，避免不必要的隐式转换。

51、什么是内联函数（Inline Function）？为什么使用内联函数？

内联函数（Inline Function）是C++中的一种函数定义方式，使用inline关键字建议编译器在调用函数时，将函数的代码直接替换到调用该函数的地方，而不是通过通常的函数调用机制（即栈操作和跳转指令）来调用。这种方法可以减少函数调用的开销，从而提高程序的执行效率。

内联函数的定义

在C++中，内联函数通过在函数定义前加上关键字inline来声明：

inline int add(int a, int b) {return a + b;
}

在这个例子中，add函数被声明为内联函数。编译器在处理add函数调用时，可能会直接将add的代码替换到调用位置。

使用内联函数的原因

减少函数调用的开销：普通函数调用会产生一定的开销，例如，压栈、跳转、返回等操作。这些操作虽然对大部分场景影响不大，但在高频率调用的小函数中，函数调用的开销可能会明显影响性能。内联函数通过将函数代码直接替换到调用位置，消除了这些开销。
增加代码的可读性和可维护性：内联函数允许开发者用函数来封装小的代码片段，这样既能提高代码的可读性和可维护性，又能避免传统函数调用的性能开销。
代码优化：编译器在处理内联函数时，可以更好地进行优化。例如，如果一个内联函数的返回值没有被使用，编译器可以直接忽略这个函数的调用。这种优化在普通函数调用中是不可能的。

内联函数的使用规则和注意事项

编译器的选择权：inline只是对编译器的建议，而不是强制命令。编译器可能会根据实际情况决定是否将函数内联。例如，如果函数体很大或者包含复杂的逻辑，编译器可能会忽略inline建议，选择常规的函数调用方式。
递归函数：递归函数不能完全内联，因为内联要求函数在编译时被替换为其代码，而递归函数在编译时调用次数是未知的。编译器通常不会内联递归函数，即使声明了inline。
内联函数定义位置：内联函数的定义通常放在头文件中。因为内联函数在编译时就需要知道其完整的定义，如果定义在源文件中，其他包含头文件的源文件无法看到完整定义，无法进行内联替换。
代码膨胀：如果内联函数体过大，且被频繁调用，内联替换可能会导致生成的可执行文件体积变大。这种情况被称为代码膨胀（code bloat）。因此，内联函数通常适用于短小的函数。
调试难度：由于内联函数在编译时被替换成了实际的代码，调试时可能无法准确看到函数调用的栈信息，增加了调试的难度。

示例

以下是一个使用内联函数的简单例子：

#include <iostream>inline int square(int x) {return x * x;
}int main() {int num = 5;std::cout << "Square of " << num << " is " << square(num) << std::endl;return 0;
}

在这个例子中，square函数被声明为内联函数。当调用square(num)时，编译器会尝试将return x * x;替换到调用位置，而不是生成一个常规的函数调用。

总结

内联函数是C++中用于优化小函数调用性能的一个工具。使用内联函数可以减少函数调用的开销，提高程序的执行效率，但同时也需要注意内联函数可能引起的代码膨胀和调试难度增加等问题。在使用内联函数时，建议将其用于短小、频繁调用的函数，避免在复杂和大型函数中使用。

52、C++中如何处理文件输入输出？

在C++中，文件输入输出（I/O）主要通过标准库<fstream>提供的类来实现。这些类包括：

std::ifstream（输入文件流）：用于读取文件。
std::ofstream（输出文件流）：用于向文件写入数据。
std::fstream（文件流）：既可以读取也可以写入文件。

基本文件操作

以下是如何使用这些类来处理文件输入输出的基本示例。

1. 读取文件：`std::ifstream`

std::ifstream类用于从文件中读取数据。以下是一个基本示例，展示如何使用std::ifstream读取文件内容。

#include <iostream>
#include <fstream>
#include <string>int main() {std::ifstream inputFile("example.txt"); // 打开文件 example.txt 进行读取if (!inputFile) {std::cerr << "无法打开文件 example.txt" << std::endl;return 1; // 如果文件无法打开，返回错误码}std::string line;while (std::getline(inputFile, line)) { // 使用getline按行读取文件std::cout << line << std::endl; // 输出每一行到控制台}inputFile.close(); // 关闭文件return 0;
}

解释：

std::ifstream inputFile("example.txt");：创建一个输入文件流inputFile并打开example.txt。
if (!inputFile)：检查文件是否成功打开，如果没有，输出错误信息并返回。
std::getline(inputFile, line)：逐行读取文件内容，line为读取的一行内容。
inputFile.close();：操作结束后关闭文件。

2. 写入文件：`std::ofstream`

std::ofstream类用于向文件写入数据。以下是一个基本示例，展示如何使用std::ofstream写入文件内容。

#include <iostream>
#include <fstream>int main() {std::ofstream outputFile("output.txt"); // 打开文件 output.txt 进行写入if (!outputFile) {std::cerr << "无法打开文件 output.txt" << std::endl;return 1; // 如果文件无法打开，返回错误码}outputFile << "这是写入文件的一行文本。" << std::endl; // 向文件写入数据outputFile << "这是另一行文本。" << std::endl;outputFile.close(); // 关闭文件return 0;
}

解释：

std::ofstream outputFile("output.txt");：创建一个输出文件流outputFile并打开output.txt。
outputFile << "这是写入文件的一行文本。" << std::endl;：向文件中写入一行文本。
outputFile.close();：操作结束后关闭文件。

3. 读写文件：`std::fstream`

std::fstream类可以同时进行读取和写入操作。以下是一个示例，展示如何使用std::fstream同时进行文件的读取和写入。

#include <iostream>
#include <fstream>
#include <string>int main() {std::fstream file("data.txt", std::ios::in | std::ios::out | std::ios::app); // 打开文件 data.txt，支持读写和追加if (!file) {std::cerr << "无法打开文件 data.txt" << std::endl;return 1; // 如果文件无法打开，返回错误码}file << "追加一行文本到文件末尾。" << std::endl; // 追加文本到文件file.seekg(0); // 将读指针移到文件开头std::string line;while (std::getline(file, line)) { // 按行读取文件内容std::cout << line << std::endl; // 输出每一行到控制台}file.close(); // 关闭文件return 0;
}

解释：

std::fstream file("data.txt", std::ios::in | std::ios::out | std::ios::app);：创建一个文件流file，以读、写和追加模式打开data.txt。
file << "追加一行文本到文件末尾。" << std::endl;：向文件末尾追加一行文本。
file.seekg(0);：将文件的读指针移到文件的开头，便于重新读取文件内容。

文件打开模式（File Open Modes）

在打开文件时，可以指定文件的打开模式。以下是常用的文件打开模式：

std::ios::in：打开文件进行读取（默认适用于ifstream）。
std::ios::out：打开文件进行写入（默认适用于ofstream）。如果文件已存在，则清空文件。
std::ios::app：打开文件进行追加操作，所有写入都附加到文件末尾。
std::ios::ate：打开文件后，将文件指针移动到文件末尾（但允许在任意位置进行读写）。
std::ios::trunc：如果文件已存在，打开时清空文件内容（默认适用于ofstream）。
std::ios::binary：以二进制模式打开文件。

注意事项

检查文件是否成功打开：在进行文件操作前，始终检查文件是否成功打开，以避免对无效文件进行操作。
关闭文件：文件操作完成后，记得关闭文件。虽然C++会在文件流对象超出作用域时自动关闭文件，但显式关闭可以更好地管理资源。
异常处理：在实际应用中，文件I/O操作可能会因为各种原因失败（如文件不存在、权限不足等），需要适当的异常处理机制来捕获并处理这些情况。

通过以上方式，C++提供了灵活且强大的文件输入输出功能，支持文本和二进制文件的高效操作。

53、解释一下C++中的命令行参数传递。

在 C++ 中，命令行参数传递是通过 main 函数的参数实现的。标准的 main 函数签名有两种形式，其中一种允许接收命令行参数：

其中：

argc 是一个整数，表示命令行参数的数量。
argv 是一个指向 C 风格字符串数组的指针，其中每个字符串对应一个命令行参数。

1、参数详细解释

argc (argument count):
- 表示传递给程序的命令行参数的个数。
- argc 至少为 1，因为第一个参数总是程序的名称（包括路径，如果有的话）。
argv (argument vector):
- 是一个指向字符数组（C 风格字符串）的指针数组。
- argv[0] 通常是程序的名称。
- argv[1] 到 argv[argc-1] 是传递给程序的实际参数。

2、示例代码

以下示例演示如何使用命令行参数：

假设程序名称为 example，并且从命令行运行它：

输出将是：

3、实际应用

命令行参数在编写命令行工具或需要配置的程序时特别有用。例如，一个接受文件名作为参数的简单文件读取程序：

运行示例：

4、注意事项

参数验证：
- 通常需要验证传递的参数个数和参数内容，以确保程序的正确性。
安全性：
- 注意处理命令行参数时的边界情况，避免缓冲区溢出等安全问题。
类型转换：
- argv 中的参数是字符串格式，可能需要将它们转换为其他类型（如整数、浮点数）来进行处理。可以使用标准库函数如 std::stoi、std::stof 等进行转换。

通过命令行参数传递，程序可以根据用户输入的不同参数来执行不同的操作，提高了程序的灵活性和可配置性。

54、什么是lambda表达式？

在C++中，Lambda表达式（或Lambda函数）是一种简洁的方式来定义匿名函数（没有名称的函数），通常用于需要一次性使用的小函数场景。Lambda表达式首次引入于C++11，为代码的简洁性和可读性提供了极大的便利，特别是在需要对STL容器进行操作或需要传递函数对象时。

Lambda表达式的语法

Lambda表达式的基本语法如下：

[capture](parameters) -> return_type {// 函数体
};

各个部分的解释如下：

capture：捕获列表，用于指定Lambda表达式中如何捕获外部作用域中的变量。
parameters：参数列表，类似于常规函数的参数列表。
return_type：返回类型，使用->符号指定。如果省略，编译器会自动推断返回类型。
函数体：Lambda函数的实际代码部分。

示例

以下是一个简单的Lambda表达式示例：

#include <iostream>int main() {// 定义一个Lambda表达式，捕获外部变量 xint x = 10;auto printX = [x]() {std::cout << "x = " << x << std::endl;};printX(); // 调用Lambda表达式return 0;
}

解释：

[x]：捕获列表，表示将外部变量x按值捕获到Lambda表达式中。
()：参数列表，这里为空，因为Lambda表达式没有参数。
{ std::cout << "x = " << x << std::endl; }：Lambda表达式的函数体，输出变量x的值。

捕获列表（Capture List）

捕获列表用于指定Lambda表达式如何访问其外部作用域中的变量。有以下几种捕获方式：

按值捕获（值传递）：通过在捕获列表中指定变量名，Lambda会捕获该变量的当前值，而不是引用外部变量。
```
int a = 5;
auto lambda = [a]() { return a * 2; }; // 按值捕获 a
```
按引用捕获：通过在变量名前加&，Lambda会捕获该变量的引用，意味着Lambda中对变量的修改会影响到外部作用域。
```
int b = 10;
auto lambda = [&b]() { b *= 2; }; // 按引用捕获 b
lambda();
std::cout << b << std::endl; // 输出 20
```
按值捕获所有外部变量（[=]）：捕获所有外部作用域中的变量，并以值传递的方式使用它们。
```
int c = 20, d = 30;
auto lambda = [=]() { return c + d; }; // 按值捕获所有变量
```

按引用捕获所有外部变量（[&]）：捕获所有外部作用域中的变量，并以引用方式使用它们。

int e = 15, f = 25;
auto lambda = [&]() { e += f; }; // 按引用捕获所有变量
lambda();
std::cout << e << std::endl; // 输出 40

混合捕获：可以同时使用按值和按引用捕获，只需在捕获列表中明确指定。

int g = 5, h = 10;
auto lambda = [g, &h]() { h += g; }; // 按值捕获 g，按引用捕获 h
lambda();
std::cout << h << std::endl; // 输出 15

Lambda表达式的返回类型

如果Lambda表达式只包含一个return语句，且返回类型可以通过该语句推断出来，那么可以省略返回类型。
```
auto add = [](int x, int y) { return x + y; }; // 返回类型为 int，编译器自动推断
```

如果Lambda表达式有多条return语句或者不止一个返回语句的代码路径，最好明确指定返回类型。

auto multiplyOrAdd = [](int x, int y, bool multiply) -> int {if (multiply) return x * y;else return x + y;
};

使用场景

Lambda表达式在以下场景中非常有用：

STL算法：在使用STL算法时，Lambda表达式可以作为回调函数，提高代码的简洁性和可读性。

#include <vector>
#include <algorithm>
#include <iostream>int main() {std::vector<int> vec = {1, 2, 3, 4, 5};std::for_each(vec.begin(), vec.end(), [](int &n) { n *= 2; }); // 使用Lambda表达式作为回调函数for (int n : vec) {std::cout << n << " "; // 输出 2 4 6 8 10}return 0;
}

一次性使用的函数：当某个逻辑只需在一处使用时，使用Lambda表达式可以避免定义命名函数的麻烦。
事件处理和回调：在GUI编程和异步编程中，Lambda表达式可以用来定义简洁的回调函数。

总结

Lambda表达式提供了一种简洁且强大的方式来定义匿名函数，可以捕获外部变量，支持各种捕获方式，并可作为函数对象在需要的地方使用。这种灵活性使得Lambda表达式在现代C++编程中非常流行，尤其是在函数式编程、事件驱动编程和泛型编程中。

55、C++中如何进行异常安全处理？

在 C++ 中，异常安全处理是一种确保程序在异常发生时仍然保持正确状态的技术。为了实现异常安全，需要采取以下几个关键步骤：

使用 RAII（Resource Acquisition Is Initialization）原则

RAII 是 C++ 中管理资源的常用技术，通过将资源的获取和释放与对象的生命周期绑定，可以自动管理资源。常见的 RAII 类型包括智能指针、锁、文件句柄等。
示例：使用智能指针

使用标准库中的异常安全容器和算法

标准库中的容器（如 std::vector）和算法（如 std::sort）通常是异常安全的，使用这些容器和算法可以减少手动管理异常的工作。

示例：异常安全的容器

编写异常安全的代码

在编写异常安全代码时，需要遵循以下几条原则：

强保证：即使发生异常，对象的状态也保持不变。
基本保证：即使发生异常，对象处于有效状态，不会导致资源泄漏。
无异常保证：函数保证不会抛出异常。

示例：异常安全的拷贝赋值运算符

使用 try-catch 块进行异常处理

在需要捕获异常的地方，使用 try-catch 块进行异常处理，确保在异常发生时能正确地释放资源或进行其他处理。

示例：使用 `try-catch` 进行异常处理

使用标准库提供的异常安全工具

标准库提供了许多异常安全工具，如智能指针（std::unique_ptr, std::shared_ptr）、标准库算法、容器等。

示例：使用 `std::lock_guard` 进行异常安全的锁管理

确保析构函数不抛出异常

析构函数应该尽量不抛出异常。如果必须抛出异常，建议使用 noexcept 声明，以避免未定义行为。

示例：析构函数中不抛出异常

通过以上这些技术和工具，可以在 C++ 中实现异常安全的代码，确保在异常发生时程序能保持正确的状态，并正确地管理资源。

56、解释一下C++中的重定向操作符（<< 和 >>）。

在 C++ 中，重定向操作符 << 和 >> 是用于流输入输出操作的操作符。它们分别称为插入操作符（<<）和提取操作符（>>），主要用于与流（如 std::cin、std::cout 和文件流等）进行交互。以下是对这两个操作符的详细解释及其用法示例。

1、插入操作符（<<）

插入操作符 << 用于将数据插入到输出流中。它常用于输出数据到控制台或文件。

用法示例

输出到控制台：

在这段代码中，std::cout << "The number is: " << num << std::endl; 将字符串 "The number is: " 和整数 num 插入到标准输出流 std::cout 中，最终显示在控制台上。

输出到文件：

在这段代码中，outFile << "Writing to file." << std::endl; 将字符串插入到文件输出流 outFile 中，写入文件 output.txt。

2、提取操作符（>>）

提取操作符 >> 用于从输入流中提取数据。它常用于从控制台或文件中读取数据。

用法示例

从控制台输入：

在这段代码中，std::cin >> num; 从标准输入流 std::cin 中提取一个整数并存储到变量 num 中。

从文件读取：

在这段代码中，std::getline(inFile, line); 从文件输入流 inFile 中逐行读取数据并存储到字符串 line 中，然后输出到控制台。

重定向操作符的重载

C++ 允许对插入操作符和提取操作符进行重载，使其能够处理用户定义的类型。

插入操作符重载示例

在这段代码中，通过重载插入操作符 operator<<，使得 std::cout << pt; 能够直接输出 Point 对象的内容。

提取操作符重载示例

在这段代码中，通过重载提取操作符 operator>>，使得 std::cin >> pt; 能够直接从输入中读取 Point 对象的内容。

总结

插入操作符 << 和提取操作符 >> 是 C++ 中用于流输入输出的重要工具。它们可以方便地处理基本数据类型和用户定义类型的数据，通过重载这些操作符，可以扩展其功能以支持更多类型的数据处理。

57、为什么使用const而不是#define来定义常量？

在C++中，使用const来定义常量比使用#define宏来定义常量有很多优势。虽然两者都可以用来定义不可改变的值，但const关键字在现代C++中更为推荐，原因如下：

1. 类型安全

const定义常量：
- const定义的常量是有类型的。编译器在编译阶段可以进行类型检查，从而避免了许多潜在的错误。
- 例如：const int maxValue = 100;，maxValue的类型是int，在使用过程中如果出现类型不匹配的情况，编译器会直接报错。
#define定义常量：
- #define定义的常量没有类型信息。它只是一个简单的文本替换，由预处理器在编译之前进行替换。这样就无法进行类型检查，可能会导致隐式类型转换带来的潜在错误。
- 例如：#define MAX_VALUE 100，在使用MAX_VALUE时，它只是被替换为100，并没有类型信息，容易造成类型不匹配的问题。

2. 作用域和可见性

const的作用域：
- const常量遵循C++作用域规则，可以定义在局部作用域内，也可以定义在类或命名空间中。
- 例如，在一个函数内定义的const常量只能在这个函数内使用，增加了代码的可维护性和可读性。
#define的作用域：
- #define宏常量在预处理阶段替换文本，因此它的作用域是全局的。宏定义后，直到文件结束或被#undef，它都是有效的。
- 这种全局可见性增加了冲突的风险，尤其是在大型项目中可能导致名称冲突。

3. 调试和编译器优化

const常量的调试和优化：
- 由于const常量有类型信息，调试时可以更好地看到其值。编译器也可以利用这些信息进行更有效的优化。
- const常量是编译时常量，编译器可以进行常量传播和内联替换等优化。
#define宏常量的调试：
- #define宏常量在编译过程中只被视为文本替换，调试时没有类型信息，只能看到替换后的字面值，难以追踪和调试。
- 预处理器只做简单的文本替换，不会进行任何优化，编译器也无法对其进行有效优化。

4. 更好的错误检查

const提供的错误检查：
- 使用const定义的常量，编译器会在编译期进行更严格的语法和类型检查，这有助于捕获代码中的错误。
- 例如：如果试图修改const常量，编译器会报错，这能有效防止常量被意外修改。
#define缺少错误检查：
- 由于#define只是文本替换，编译器无法检查宏的类型和合法性，容易产生难以发现的错误。
- 例如：如果你定义了#define PI 3.14，在代码中意外地使用PI = 3.14159;，编译器不会报错，但会导致代码逻辑错误。

5. 命名空间支持

const支持命名空间：
- const常量可以定义在命名空间中，这样可以有效避免名称冲突，尤其在大型项目中，命名空间是管理符号的一个非常有效的工具。
#define不支持命名空间：
- #define宏定义不支持命名空间，它的作用域无法被限制在某个命名空间内，容易和其他宏或变量发生冲突。

6. 改进的C++风格

符合C++风格：
- C++语言强调类型安全和可读性，使用const关键字符合C++的编程风格和设计理念。现代C++代码风格提倡尽量避免使用宏。
#define宏的局限性：
- #define是从C语言继承下来的特性，不符合C++的类型安全和作用域管理规则。在C++中，应该尽量避免使用宏来定义常量。

结论

在C++中，使用const定义常量比使用#define宏更安全和灵活。const提供了类型安全、作用域控制、调试支持和编译器优化等优势，使代码更加可靠和易于维护。尽管#define可以在某些简单场景中使用，但在现代C++开发中，推荐使用const来定义常量。

58、引用和指针

这两者之间有明显的区别，让我逐一解释：

int& ref = x;：
- 这是一个引用的定义，ref 是一个整型的引用，它引用了变量 x。
- 引用是一个别名，通过引用可以直接访问到被引用的对象，修改引用也会修改原始对象。
- 这意味着对 ref 的操作实际上就是对 x 的操作。
- 引用在定义时必须立即初始化，并且一旦初始化完成，它将一直引用同一个对象。

现在 ref 引用了变量 x。我们可以通过 ref 来访问和修改变量 x：

int* ptr = &x;：
- 这是一个指针的定义，ptr 是一个指向整型的指针，它存储了变量 x 的地址。
- 指针是一个变量，它存储了另一个变量的地址，通过指针可以间接地访问到原始对象。
- 指针的值可以修改，即可以指向其他地址，但是它所指向的对象不能被修改（除非使用指针的指针或引用）。
- 指针可以先定义，再初始化。

现在 ptr 存储了变量 x 的地址。我们可以通过 ptr 来访问和修改变量

总的来说，引用和指针都是用来间接访问对象的，但它们的语法和用法有所不同，具体使用取决于需求和场景。通常情况下，引用更安全、更直观，而指针更灵活、更强大。

在某种程度上，是的，使用引用和指针都可以间接地访问和修改原始变量的值。但是，它们之间还是有一些关键的区别：

59、简述一下全局变量？

全局变量（Global Variable）是指在程序的任何地方都能访问和使用的变量。它们在定义时具有全局范围（global scope），通常在文件的顶层定义，并在程序的整个生命周期内存在。

1、特点

定义位置：全局变量通常在文件的最外层定义，位于所有函数和类的外部。
作用域：全局变量的作用域是整个程序，从定义它的点开始直到程序结束。
生命周期：全局变量在程序开始时分配内存，在程序结束时释放内存。它们在整个程序运行期间始终存在。
默认初始化：如果没有显式初始化，全局变量会被默认初始化为零（对于数值类型）或空（对于指针类型）。

2、使用全局变量的优点

方便访问：由于全局变量在程序的任何地方都可以访问，使用非常方便。
跨函数共享数据：全局变量可以在不同的函数之间共享数据，而不需要通过参数传递。

4、使用全局变量的缺点

可维护性差：全局变量的使用会使代码的可读性和可维护性降低，因为它们可能会在程序的任何地方被修改。
命名冲突：如果多个文件中使用相同名称的全局变量，可能会导致命名冲突和难以调试的问题。
难以跟踪状态变化：由于全局变量可以在程序的任何地方被修改，跟踪它们的状态变化会变得困难。
线程安全问题：在多线程程序中，全局变量的并发访问可能会导致数据竞争和不一致的问题。

5 示例

以下是一个简单的示例，展示了如何定义和使用全局变量：

在这个示例中，globalCounter 是一个全局变量，可以在 incrementCounter 和 printCounter 函数中访问和修改。

多文件程序中的全局变量

在多文件程序中，如果需要在不同的文件中访问同一个全局变量，需要使用 extern 关键字进行声明：

file1.cpp

file2.cpp

在这个示例中，file1.cpp 中定义了全局变量 globalCounter，并在 file2.cpp 中使用 extern 关键字声明了该变量，从而在两个文件中共享同一个全局变量。

59、在一个文件里边定义的全局变量，可以在另一个文件中访问吗

在一个文件中定义的全局变量可以在另一个文件中访问，但需要使用 extern 关键字进行声明。以下是详细的步骤和示例：

1、定义和访问全局变量

file1.cpp

在 file1.cpp 中定义全局变量 globalCounter：

file2.cpp

在 file2.cpp 中使用 extern 关键字声明该全局变量，并定义操作该变量的函数：

编译和链接

确保两个文件都被编译，并且在链接时一起使用：

运行结果

运行程序 ./myProgram，输出如下：

2、原理解释

定义和声明的区别：
- 定义：在 file1.cpp 中 int globalCounter = 0; 是定义，它实际分配存储空间。
- 声明：在 file2.cpp 中 extern int globalCounter; 是声明，它告诉编译器 globalCounter 是在别处定义的，并且在链接时可以找到它。
extern 关键字：
- extern 告诉编译器该变量是在其他地方定义的，并且链接时会解决该变量的地址。
编译和链接：
- g++ file1.cpp file2.cpp -o myProgram 命令编译两个源文件并链接成一个可执行文件。在链接阶段，编译器将 file1.cpp 中定义的 globalCounter 和 file2.cpp 中声明的 globalCounter 关联起来。