Effective C++_第二篇-Aet

Bingliaolong 2024-07-01 15:17 Aet | 隐藏边栏 | 抢沙发 | 3 0

文章评分 1 次，平均分 5.0 ：

12 复制对象的所有部分

概述

在C++中，实现拷贝构造函数和赋值运算符时，确保复制对象的所有成员变量是至关重要的
忽略某些成员变量可能会导致不完整或错误的对象状态，进而引发难以追踪的错误

为什么要复制对象的所有部分

保持对象的一致性：
1. 所有成员变量都应该在拷贝时保持一致，以确保新对象的状态与原对象相同
防止资源泄漏：
1. 如果对象管理动态资源（如内存、文件句柄等），在拷贝时必须正确处理这些资源以防止泄漏
确保正确行为：
1. 忽略某些成员变量可能导致新对象行为异常或不完整

实现

在实现拷贝构造函数和赋值运算符时，确保所有成员变量都被正确拷贝

示例代码

一个包含动态内存分配和其他成员变量的类的完整示例，展示如何正确实现拷贝构造函数和赋值运算符：

#include <iostream>

#include <cstring>

class MyString {

private:

char* data;

int length;

public:

// 构造函数

MyString(const char* str = "") {

length = strlen(str);

data = new char[length + 1];

strcpy(data, str);

}

// 拷贝构造函数

MyString(const MyString& other) {

length = other.length; // 复制长度

data = new char[length + 1]; // 分配新内存

strcpy(data, other.data); // 复制数据

}

// 赋值运算符

MyString& operator=(const MyString& rhs) {

if (this != &rhs) { // 检查自我赋值

char* newData = new char[rhs.length + 1]; // 分配新内存

strcpy(newData, rhs.data); // 复制数据

delete[] data; // 释放旧内存

data = newData; // 更新指针

length = rhs.length; // 复制长度

}

return *this; // 返回当前对象的引用

}

// 移动构造函数

MyString(MyString&& other) noexcept {

data = other.data;

length = other.length;

other.data = nullptr;

other.length = 0;

}

// 移动赋值运算符

MyString& operator=(MyString&& rhs) noexcept {

if (this != &rhs) {

delete[] data; // 释放旧内存

data = rhs.data; // 移动数据指针

length = rhs.length; // 移动长度

rhs.data = nullptr; // 防止rhs析构时删除资源

rhs.length = 0;

}

return *this;

}

// 析构函数

~MyString() {

delete[] data;

}

// 打印字符串

void print() const {

std::cout << data << std::endl;

}

};

int main() {

MyString str1("Hello");

MyString str2("World");

str1 = str2; // 使用赋值运算符

str1.print(); // 输出 "World"

MyString str3 = str1; // 使用拷贝构造函数

str3.print(); // 输出 "World"

MyString str4("Move");

str4 = std::move(str1); // 使用移动赋值运算符

str4.print(); // 输出 "World"

str1.print(); // 输出空字符串，str1被移动为空

return 0;

}

13 使用对象管理资源

概述

在C++编程中，资源管理（如动态内存、文件句柄、网络连接等）是一个重要而复杂的任务
1. 如果不正确管理资源，容易导致资源泄漏或未定义行为
使用对象来管理资源，通过RAII（Resource Acquisition Is Initialization）原则确保资源在对象的生命周期内被正确管理

RAII（资源获取即初始化）

RAII是一种编程惯例，即资源的获取与对象的初始化绑定在一起，资源的释放与对象的销毁绑定在一起
通过RAII，可以确保资源在对象的构造函数中获取，在析构函数中释放，从而避免资源泄漏

示例代码

#include <iostream>

#include <cstring>

// 自定义字符串类，使用RAII管理动态内存

class MyString {

private:

char* data;

public:

// 构造函数

MyString(const char* str = "") {

data = new char[strlen(str) + 1];

strcpy(data, str);

}

// 拷贝构造函数

MyString(const MyString& other) {

data = new char[strlen(other.data) + 1];

strcpy(data, other.data);

}

// 移动构造函数

MyString(MyString&& other) noexcept {

data = other.data;

other.data = nullptr;

}

// 拷贝赋值运算符

MyString& operator=(const MyString& other) {

if (this != &other) {

delete[] data;

data = new char[strlen(other.data) + 1];

strcpy(data, other.data);

}

return *this;

}

// 移动赋值运算符

MyString& operator=(MyString&& other) noexcept {

if (this != &other) {

delete[] data;

data = other.data;

other.data = nullptr;

}

return *this;

}

// 析构函数

~MyString() {

delete[] data;

}

// 打印字符串

void print() const {

if (data) {

std::cout << data << std::endl;

} else {

std::cout << "String is empty" << std::endl;

}

};

int main() {

MyString str1("Hello");

MyString str2("World");

str1 = str2; // 使用拷贝赋值运算符

str1.print(); // 输出 "World"

MyString str3 = std::move(str1); // 使用移动构造函数

str3.print(); // 输出 "World"

str1.print(); // 输出 "String is empty"

return 0;

}

在构造函数中分配动态内存，并将传入的字符串复制到内部数据成员中

MyString(const char* str = "") {

data = new char[strlen(str) + 1];

strcpy(data, str);

}

在拷贝构造函数中分配新的内存，并将原对象的数据复制过来

MyString(const MyString& other) {

data = new char[strlen(other.data) + 1];

strcpy(data, other.data);

}

在移动构造函数中，将源对象的数据指针移动到当前对象，并将源对象的数据指针置为空

MyString(MyString&& other) noexcept {

data = other.data;

other.data = nullptr;

}

拷贝赋值运算符中，先检查自我赋值，然后分配新内存并复制数据，最后释放旧内存

MyString& operator=(const MyString& other) {

if (this != &other) {

delete[] data;

data = new char[strlen(other.data) + 1];

strcpy(data, other.data);

}

return *this;

}

在移动赋值运算符中，先检查自我赋值，然后释放旧内存，将源对象的数据指针移动到当前对象，并将源对象的数据指针置为空

MyString& operator=(MyString&& other) noexcept {

if (this != &other) {

delete[] data;

data = other.data;

other.data = nullptr;

}

return *this;

}

在析构函数中释放动态分配的内存

~MyString() {

delete[] data;

}

14 在资源管理类中仔细考虑复制行为

概述

在设计资源管理类时，需要特别注意复制行为（拷贝构造和赋值操作）的实现方式
正确处理这些操作可以避免资源泄漏、双重释放等问题，确保对象的行为符合预期

资源管理类的复制问题

在资源管理类中，如果不正确处理复制操作，可能会导致以下问题：
资源泄漏：
1. 没有正确释放旧资源或处理新资源时可能会导致资源泄漏
双重释放：
1. 多个对象共享同一个资源，但在销毁时尝试释放同一个资源，导致未定义行为
浅拷贝问题：
1. 复制对象时只是复制了指针，而不是指针指向的资源，这会导致两个对象共享同一个资源

解决方案

禁用复制操作
1. 如果不需要对象的复制操作，可以通过删除拷贝构造函数和赋值运算符来禁用它们

class Resource {

public:

Resource() {

// 分配资源

}

~Resource() {

// 释放资源

}

// 禁用拷贝构造函数

Resource(const Resource&) = delete;

// 禁用赋值运算符

Resource& operator=(const Resource&) = delete;

};

实现深拷贝
1. 如果需要复制对象，应确保每个对象都有自己的独立资源副本。实现深拷贝可以确保资源的独立性

#include <iostream>

#include <cstring>

class MyString {

private:

char* data;

public:

// 构造函数

MyString(const char* str = "") {

data = new char[strlen(str) + 1];

strcpy(data, str);

}

// 拷贝构造函数

MyString(const MyString& other) {

data = new char[strlen(other.data) + 1];

strcpy(data, other.data);

}

// 赋值运算符

MyString& operator=(const MyString& rhs) {

if (this != &rhs) {

char* newData = new char[strlen(rhs.data) + 1];

strcpy(newData, rhs.data);

delete[] data;

data = newData;

}

return *this;

}

// 析构函数

~MyString() {

delete[] data;

}

// 打印字符串

void print() const {

std::cout << data << std::endl;

}

};

int main() {

MyString str1("Hello");

MyString str2 = str1; // 使用拷贝构造函数

str1.print(); // 输出 "Hello"

str2.print(); // 输出 "Hello"

str2 = "World"; // 使用赋值运算符

str1.print(); // 输出 "Hello"

str2.print(); // 输出 "World"

return 0;

}

使用智能指针
1. 在现代C++中，使用智能指针（如std::unique_ptr和std::shared_ptr）可以简化资源管理，并自动处理复制和销毁操作

#include <iostream>

#include <memory>

class Resource {

public:

Resource() {

std::cout << "Resource acquired" << std::endl;

}

~Resource() {

std::cout << "Resource released" << std::endl;

}

};

class ResourceManager {

private:

std::unique_ptr<Resource> resource;

public:

ResourceManager() : resource(std::make_unique<Resource>()) {}

// 禁用拷贝构造函数和赋值运算符

ResourceManager(const ResourceManager&) = delete;

ResourceManager& operator=(const ResourceManager&) = delete;

// 允许移动构造和移动赋值

ResourceManager(ResourceManager&&) noexcept = default;

ResourceManager& operator=(ResourceManager&&) noexcept = default;

};

int main() {

ResourceManager manager1;

ResourceManager manager2 = std::move(manager1); // 使用移动构造函数

return 0;

}

15 在资源管理类中提供对原始资源的访问

概述

在资源管理类中提供对底层资源（如指针、文件句柄、网络连接等）的访问方法
虽然RAII（Resource Acquisition Is Initialization）可以自动管理资源的生命周期，但有时仍需要直接访问这些底层资源，以便与使用原始资源的API交互

为什么需要提供对原始资源的访问

与外部API交互：
1. 某些库或API需要直接使用原始资源
2. 例如，操作系统API通常需要原始指针或句柄
提高灵活性：
1. 在某些情况下，直接访问底层资源可以提高代码的灵活性和效率

如何提供对原始资源的访问？

常量访问：
1. 提供只读访问，不允许修改资源
非常量访问：
1. 提供可修改访问，允许对资源进行修改

#include <iostream>

#include <cstring>

class MyString {

private:

char* data;

public:

// 构造函数

MyString(const char* str = "") {

data = new char[strlen(str) + 1];

strcpy(data, str);

}

// 拷贝构造函数

MyString(const MyString& other) {

data = new char[strlen(other.data) + 1];

strcpy(data, other.data);

}

// 移动构造函数

MyString(MyString&& other) noexcept {

data = other.data;

other.data = nullptr;

}

// 拷贝赋值运算符

MyString& operator=(const MyString& other) {

if (this != &other) {

char* newData = new char[strlen(other.data) + 1];

strcpy(newData, other.data);

delete[] data;

data = newData;

}

return *this;

}

// 移动赋值运算符

MyString& operator=(MyString&& other) noexcept {

if (this != &other) {

delete[] data;

data = other.data;

other.data = nullptr;

}

return *this;

}

// 析构函数

~MyString() {

delete[] data;

}

// 提供对底层数据的常量访问

const char* getData() const {

return data;

}

// 提供对底层数据的非常量访问

char* getData() {

return data;

}

// 打印字符串

void print() const {

std::cout << data << std::endl;

}

};

void useRawPointer(const char* rawStr) {

std::cout << "Using raw pointer: " << rawStr << std::endl;

}

int main() {

MyString str("Hello, world!");

str.print();

// 使用常量访问

const char* rawData = str.getData();

useRawPointer(rawData);

// 使用非常量访问

char* modifiableData = str.getData();

strcpy(modifiableData, "Hello, C++!");

str.print();

return 0;

}

16 在对应的new和delete使用中使用相同的形式

概述

如果使用new分配单个对象，就应该使用delete释放单个对象
如果使用new[]分配数组，就应该使用delete[]释放数组
否则会导致未定义行为

为什么要保持一致性

内存管理一致性：
1. C++的内存分配和释放机制要求使用匹配的形式
2. 如果不匹配，会导致内存泄漏或程序崩溃
避免未定义行为：
1. 不匹配的new和delete形式会导致未定义行为，可能会破坏程序的稳定性和安全性

示例代码

#include <iostream>

class MyClass {

public:

MyClass() {

std::cout << "MyClass constructor" << std::endl;

}

~MyClass() {

std::cout << "MyClass destructor" << std::endl;

}

};

int main() {

// 分配和释放单个对象

MyClass* obj = new MyClass(); // 使用new分配单个对象

delete obj; // 使用delete释放单个对象

// 分配和释放数组

MyClass* objArray = new MyClass[3]; // 使用new[]分配数组

delete[] objArray; // 使用delete[]释放数组

return 0;

}

MyClass constructor

MyClass destructor

MyClass constructor

MyClass destructor

17 将通过new分配的对象存储在智能指针中，并且要使用独立语句

概述

在使用new操作符分配对象时，应将其存储在智能指针中，以避免内存泄漏
同时，建议使用独立的语句来进行分配和存储，以确保异常安全性

为什么使用智能指针

智能指针（如std::unique_ptr和std::shared_ptr）自动管理动态分配的对象的生命周期
确保在不再使用对象时自动释放内存，防止内存泄漏

为什么使用独立语句

在复杂的表达式中同时进行对象分配和智能指针初始化，可能会导致异常安全性问题
如果在分配对象之后但在智能指针初始化之前抛出异常，可能会导致内存泄漏
1. 因此，建议使用独立语句来分配对象并将其存储在智能指针中

示例代码

#include <iostream>

#include <memory>

class MyClass {

public:

MyClass() {

std::cout << "MyClass constructor" << std::endl;

}

~MyClass() {

std::cout << "MyClass destructor" << std::endl;

}

};

void example() {

// 使用独立语句进行分配和存储

std::unique_ptr<MyClass> ptr1(new MyClass());

// 或者更简洁的方式（C++14及以上）

auto ptr2 = std::make_unique<MyClass>();

}

int main() {

example();

return 0;

}

注意

上面的写法中，最推荐的是：
1. auto ptr2 = std::make_unique<MyClass>();
第二推荐的是：
1. std::unique_ptr<MyClass> ptr1(new MyClass());
不推荐的写法是：
1. 在分配对象之后但在智能指针初始化之前，如果发生异常（例如，在其他代码中抛出异常），会导致内存泄漏
  会发生异常的原因，是无法保证这两行中间会不会加可能抛出异常的代码
2. 分开写会使代码变得冗长，不如使用 std::make_unique 简洁和安全

1 2	auto ptr = new MyClass(); std::unique_ptr<MyClass> ptr1(ptr);

不推荐上面写法的原因：
1. 单线程环境中，如果可以保证这两行是挨着的，中间不会有其他代码，那么不会有上述的异常导致的内存泄漏
2. 多线程环境中，任然有一种可能性极地的情况：
  刚构造完对象，两行代码之间发生了线程切换，并且在其他线程在切换期间引发了影响全局状态的异常，就可能出现问题
额外的解析：
1. 如果这里的异常发生后，throw这一行下面的代码是不会有机会执行的，控制流立即跳转到对应的异常处理程序（catch 块），并跳过 throw 语句之后的所有代码
2. 如果异常发生后，整个程序还在运行，那么 new 分配的 ptr 这一块空间就泄漏了
3. 多线程环境中，每个线程都有自己的异常处理上下文，因此线程之间的异常处理是独立的

void example() {

MyClass* ptr = new MyClass(); // 分配对象

// 在智能指针初始化之前发生异常

throw std::runtime_error("Exception occurred!");

std::unique_ptr<MyClass> ptr1(ptr); // 初始化智能指针

}

18 使接口易于正确使用，难于误用

概述

良好的接口设计可以减少用户犯错误的机会，提高代码的可读性和可维护性

原则和策略

合理使用类型系统
1. 使用合适的类型来表达函数参数的含义
2. 例如，使用std::string表示字符串而不是char*，使用std::vector表示动态数组而不是C风格的数组
使用明确的命名
1. 为函数和变量选择有意义且自解释的名称，避免使用模糊的缩写或不相关的名称
提供合理的默认值
1. 为函数参数提供合理的默认值，避免用户必须提供不必要的参数
限制接口的复杂性
1. 尽量保持接口的简洁性，避免用户必须记住太多的细节
防止错误的使用
1. 使用类型系统和编译时检查来防止常见的错误
2. 例如，使用enum来表示一组相关的常量，而不是使用int
使用RAII和智能指针
1. 通过使用RAII（Resource Acquisition Is Initialization）和智能指针来管理资源，减少用户手动管理资源的负担，避免资源泄漏

示例代码

#include <iostream>

#include <string>

#include <vector>

// 错误示例：使用原始指针

void processString(char* str) {

// 处理字符串

}

// 正确示例：使用std::string

void processString(const std::string& str) {

// 处理字符串

}

// 错误示例：使用原始数组

void processArray(int* arr, size_t size) {

// 处理数组

}

// 正确示例：使用std::vector

void processArray(const std::vector<int>& arr) {

// 处理数组

}

#include <iostream>

// 错误示例：模糊的函数命名

void f(int a, int b) {

// 做一些事情

}

// 正确示例：明确的函数命名

void setWindowSize(int width, int height) {

// 设置窗口大小

}

#include <iostream>

#include <string>

// 错误示例：必须提供所有参数

void createUser(const std::string& name, int age, const std::string& address) {

// 创建用户

}

// 正确示例：提供默认值

void createUser(const std::string& name, int age = 18, const std::string& address = "Unknown") {

// 创建用户

}

#include <iostream>

#include <string>

// 错误示例：复杂的接口

void process(const std::string& str, bool flag, int mode, double value) {

// 处理

}

// 正确示例：简化接口

void process(const std::string& str) {

// 处理

}

#include <iostream>

// 错误示例：使用int表示状态

void setStatus(int status) {

// 设置状态

}

// 正确示例：使用enum表示状态

enum class Status { OK, ERROR, UNKNOWN };

void setStatus(Status status) {

// 设置状态

}

#include <iostream>

#include <memory>

// 错误示例：手动管理资源

void process() {

int* data = new int[100];

// 处理数据

delete[] data;

}

// 正确示例：使用智能指针

void process() {

auto data = std::make_unique<int[]>(100);

// 处理数据

}

19 将类设计视为类型设计

概述

设计类时应该将其视为创建一个新类型的过程

原则和策略

明确类的职责
1. 确保每个类有明确的职责，遵循单一职责原则（Single Responsibility Principle）
2. 类应该只做一件事，并把它做好

#include <iostream>

#include <string>

// 错误示例：类有多个职责

class User {

public:

std::string name;

int age;

std::string address;

void saveToFile(const std::string& filename) {

// 保存用户信息到文件

}

void loadFromFile(const std::string& filename) {

// 从文件加载用户信息

}

};

// 正确示例：类只有单一职责

class User {

public:

std::string name;

int age;

std::string address;

};

class UserPersistence {

public:

void saveToFile(const User& user, const std::string& filename) {

// 保存用户信息到文件

}

void loadFromFile(User& user, const std::string& filename) {

// 从文件加载用户信息

}

};

封装实现细节
1. 封装类的实现细节，通过公共接口与外部进行交互
2. 避免暴露类的内部实现，使其可以在不影响外部代码的情况下进行修改

#include <iostream>

#include <string>

// 错误示例：暴露实现细节

class Stack {

public:

int* data;

int top;

int capacity;

void push(int value) {

// 推入数据

}

int pop() {

// 弹出数据

}

};

// 正确示例：封装实现细节

class Stack {

private:

int* data;

int top;

int capacity;

public:

Stack(int capacity) : data(new int[capacity]), top(-1), capacity(capacity) {}

~Stack() {

delete[] data;

}

void push(int value) {

// 推入数据

}

int pop() {

// 弹出数据

}

bool isEmpty() const {

return top == -1;

}

bool isFull() const {

return top == capacity - 1;

}

};

使用一致的接口
1. 保持类的接口一致和直观
2. 使用命名规范和一致的参数类型，使类的使用更加方便和易于理解

#include <iostream>

#include <string>

// 错误示例：不一致的接口

class Rectangle {

public:

int get_width() const { return width; }

int get_height() const { return height; }

void set_dimensions(int w, int h) { width = w; height = h; }

private:

int width;

int height;

};

// 正确示例：一致的接口

class Rectangle {

public:

int getWidth() const { return width; }

int getHeight() const { return height; }

void setWidth(int w) { width = w; }

void setHeight(int h) { height = h; }

private:

int width;

int height;

};

支持类型安全
1. 确保类的操作是类型安全的，防止错误的使用
2. 使用适当的类型和编译时检查来确保类型安全性

#include <iostream>

#include <string>

// 错误示例：不安全的类型转换

class User {

public:

std::string name;

int age;

};

void processUser(void* user) {

User* u = static_cast<User*>(user);

std::cout << u->name << std::endl;

}

// 正确示例：使用类型安全的接口

class User {

public:

std::string name;

int age;

};

void processUser(const User& user) {

std::cout << user.name << std::endl;

}

提供必要的操作
1. 提供类的基本操作，如构造函数、析构函数、拷贝构造函数、赋值运算符等，使类的行为符合预期

#include <iostream>

#include <string>

// 错误示例：未提供必要的操作

class User {

public:

std::string name;

int age;

};

// 正确示例：提供必要的操作

class User {

public:

std::string name;

int age;

User(const std::string& name, int age) : name(name), age(age) {}

User(const User& other) : name(other.name), age(other.age) {}

User& operator=(const User& other) {

if (this != &other) {

name = other.name;

age = other.age;

}

return *this;

}

};

考虑类的扩展性
1. 设计类时要考虑未来的扩展性，确保类可以方便地添加新功能或修改现有功能，而不破坏现有代码

#include <iostream>

#include <string>

// 错误示例：难以扩展

class User {

public:

std::string name;

int age;

void print() const {

std::cout << "Name: " << name << ", Age: " << age << std::endl;

}

};

// 正确示例：易于扩展

class User {

public:

std::string name;

int age;

virtual void print() const {

std::cout << "Name: " << name << ", Age: " << age << std::endl;

}

};

class Admin : public User {

public:

std::string role;

void print() const override {

std::cout << "Name: " << name << ", Age: " << age << ", Role: " << role << std::endl;

}

};

20 优先选择传递常量引用而不是传值

概述

在函数参数传递时，优先选择通过常量引用传递对象，而不是通过值传递
1. 这样做可以提高程序的效率，特别是当传递大对象或复杂对象时

为什么优先选择传递常量引用

性能
1. 传递大对象或复杂对象时，传值会导致对象的拷贝构造函数被调用，从而增加开销
2. 而通过常量引用传递则避免了这种不必要的拷贝
避免拷贝
1. 某些对象可能不允许复制（例如，禁止拷贝的对象），通过常量引用传递可以避免这种问题
一致性
1. 在C++中，许多标准库函数都采用传递常量引用的方式，这是一种常见且推荐的做法

适用场景

大对象或复杂对象：
1. 当对象的拷贝开销较大时，通过常量引用传递可以显著提高效率
不可复制对象：
1. 当对象不允许复制时（例如，禁用拷贝构造函数），通过常量引用传递是唯一可行的方式
保持对象的状态：
1. 通过常量引用传递可以确保函数内部不修改传递的对象，从而保持对象的状态一致性

示例代码

传值方式

#include <iostream>

#include <string>

class MyClass {

public:

MyClass() {

std::cout << "MyClass constructor" << std::endl;

}

MyClass(const MyClass& other) {

std::cout << "MyClass copy constructor" << std::endl;

}

void display() const {

std::cout << "Display MyClass object" << std::endl;

}

};

void processByValue(MyClass obj) {

obj.display();

}

int main() {

MyClass obj;

processByValue(obj);

return 0;

}

MyClass constructor

MyClass copy constructor

Display MyClass object

通过常量引用传递

#include <iostream>

#include <string>

class MyClass {

public:

MyClass() {

std::cout << "MyClass constructor" << std::endl;

}

MyClass(const MyClass& other) {

std::cout << "MyClass copy constructor" << std::endl;

}

void display() const {

std::cout << "Display MyClass object" << std::endl;

}

};

void processByConstRef(const MyClass& obj) {

obj.display();

}

int main() {

MyClass obj;

processByConstRef(obj);

return 0;

}

1 2	MyClass constructor Display MyClass object

21 在必须返回对象时，不要试图返回引用

概述

在设计函数返回类型时，如果需要返回一个新创建的对象，应该返回对象本身而不是引用
返回引用可能会导致未定义行为和难以调试的错误

为什么不要返回引用

生命周期问题：
1. 如果返回一个局部对象的引用，当函数返回后，该局部对象会被销毁，导致引用指向无效内存
未定义行为：
1. 返回局部对象的引用会导致未定义行为，使用这样的引用可能会导致程序崩溃或意外行为
易于调试：
1. 返回对象而不是引用可以避免难以调试的错误，因为对象的生命周期和所有权更加明确

适用场景

返回局部对象：
1. 如果函数需要返回一个在函数内部创建的局部对象，应该返回对象本身而不是引用
返回临时对象：
1. 如果函数返回一个临时对象，应该返回对象本身以确保对象的生命周期在函数返回后仍然有效

示例代码

错误做法

#include <iostream>

#include <string>

class MyClass {

public:

MyClass(const std::string& name) : name(name) {}

void display() const {

std::cout << "Name: " << name << std::endl;

}

private:

std::string name;

};

MyClass& createObject() {

MyClass obj("Temporary Object");

return obj; // 错误：返回局部对象的引用

}

int main() {

MyClass& myObj = createObject();

myObj.display(); // 未定义行为

return 0;

}

正确做法

#include <iostream>

#include <string>

class MyClass {

public:

MyClass(const std::string& name) : name(name) {}

void display() const {

std::cout << "Name: " << name << std::endl;

}

private:

std::string name;

};

MyClass createObject() {

MyClass obj("Temporary Object");

return obj; // 正确：返回对象本身

}

int main() {

MyClass myObj = createObject();

myObj.display(); // 正常工作

return 0;

}

22 将数据成员声明为私有

概述

在设计类时，应将数据成员声明为私有
这样可以保护数据，控制对数据的访问，并保持类的封装性和数据完整性

为什么要将数据成员声明为私有

封装性：
1. 通过将数据成员声明为私有，类可以控制外部代码对数据的访问和修改
2. 这是面向对象编程的基本原则之一，称为封装
数据完整性：
1. 私有数据成员可以防止外部代码直接修改数据，确保数据的一致性和完整性
2. 所有对数据的修改都必须通过类的公共接口进行
灵活性：
1. 私有数据成员允许类的实现细节随时改变而不影响外部代码
2. 只要公共接口保持不变，类的内部实现可以随意调整
可维护性：
1. 将数据成员声明为私有可以提高代码的可维护性和可读性
2. 其他开发人员在使用类时，不需要了解类的内部实现，只需了解类的公共接口

示例代码

错误做法

#include <iostream>

#include <string>

class MyClass {

public:

std::string name; // 公有数据成员

void display() const {

std::cout << "Name: " << name << std::endl;

}

};

int main() {

MyClass obj;

obj.name = "Hello"; // 直接访问和修改数据成员

obj.display();

return 0;

}

正确做法

#include <iostream>

#include <string>

class MyClass {

private:

std::string name; // 私有数据成员

public:

// 构造函数

MyClass(const std::string& name) : name(name) {}

// 访问器函数

std::string getName() const {

return name;

}

// 修改器函数

void setName(const std::string& newName) {

name = newName;

}

void display() const {

std::cout << "Name: " << name << std::endl;

}

};

int main() {

MyClass obj("Hello");

obj.display();

obj.setName("World"); // 通过公共接口修改数据成员

obj.display();

return 0;

}

12 复制对象的所有部分
概述
为什么要复制对象的所有部分
实现
示例代码
13 使用对象管理资源
概述
RAII（资源获取即初始化）
示例代码
14 在资源管理类中仔细考虑复制行为
概述
资源管理类的复制问题
解决方案
15 在资源管理类中提供对原始资源的访问
概述
为什么需要提供对原始资源的访问
如何提供对原始资源的访问？
16 在对应的new和delete使用中使用相同的形式
概述
为什么要保持一致性
示例代码
17 将通过new分配的对象存储在智能指针中，并且要使用独立语句
概述
为什么使用智能指针
为什么使用独立语句
示例代码
注意
18 使接口易于正确使用，难于误用
概述
原则和策略
示例代码
19 将类设计视为类型设计
概述
原则和策略
20 优先选择传递常量引用而不是传值
概述
为什么优先选择传递常量引用
适用场景
示例代码
21 在必须返回对象时，不要试图返回引用
概述
为什么不要返回引用
适用场景
示例代码
22 将数据成员声明为私有
概述
为什么要将数据成员声明为私有
示例代码

本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0 最后编辑于：2024-07-02

Everything will be better.

2025年 4月
一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

Effective C++_第二篇

12 复制对象的所有部分

概述

为什么要复制对象的所有部分

实现

示例代码

13 使用对象管理资源

概述

RAII（资源获取即初始化）

示例代码

14 在资源管理类中仔细考虑复制行为

概述

资源管理类的复制问题

解决方案

15 在资源管理类中提供对原始资源的访问

概述

为什么需要提供对原始资源的访问

如何提供对原始资源的访问？

16 在对应的new和delete使用中使用相同的形式

概述

为什么要保持一致性

示例代码

17 将通过new分配的对象存储在智能指针中，并且要使用独立语句

概述

为什么使用智能指针

为什么使用独立语句

示例代码

注意

18 使接口易于正确使用，难于误用

概述

原则和策略

示例代码

19 将类设计视为类型设计

概述

原则和策略

20 优先选择传递常量引用而不是传值

概述

为什么优先选择传递常量引用

适用场景

示例代码

21 在必须返回对象时，不要试图返回引用

概述

为什么不要返回引用

适用场景

示例代码

22 将数据成员声明为私有

概述

为什么要将数据成员声明为私有

示例代码

你可能也喜欢

热评文章

发表评论

标签云集