Effective C++ 阅读心得-条款01：视C++为一个语言联邦

最重要的话放在前面

• C++高效编程守则视状况而变化，取决于你使用C++的哪一部分。

大白话

当今的C++支持多种形式的编程语言：面向过程编程，面向对象编程，函数形式编程，范型编程，元编程，这些能力组成了一个强无敌的编程语言，但各个部分又似乎自成一派，所以，想要驾驭这样强大的编程语言，就要了解C++中各个次语言的特点，并在合适的场景使用它们。

1. 哪一部分是哪几部分

1. C 语言：C++ 是在 C 语言基础上发展而来的，因此 C++ 包含了 C 语言的大部分特性和语法。
2. 面向对象编程语言：C++ 支持面向对象编程（OOP）的特性，包括封装、继承、多态等。
3. 泛型编程语言：C++ 支持泛型编程，即编写不依赖于具体类型的代码，可以使用模板（template）实现泛型编程；崭新编程范型C++ 支持元编程，即编写程序来生成程序的过程，可以使用模板元编程（TMP）来实现。
4. STL：template程序库，是 C++ 标准库中的一个重要组成部分，提供了大量的数据结构和算法，使 C++ 程序员能够更加高效地编写程序。
   我觉得应该还可以加上以下两方面
5. 并发编程语言：C++ 支持多线程和并发编程，可以使用标准库中的线程、原子类型和锁等机制来实现。
6. 高级编程语言支持：C++ 支持高级编程特性，如异常处理、RTTI（运行时类型识别）和智能指针等。

2. C++的高效编程如何视情况而变化呢？

2.1 前言

C++ 是一门非常灵活的语言，可以用于多种不同的应用场景和问题领域。因此，在编写高效的 C++ 代码时，需要根据实际应用场景和使用的 C++ 特性来确定最佳实践和编程守则。

举例来说，如果正在编写一个嵌入式系统，那么可能需要关注内存使用和指针的安全性，以避免由于内存泄漏和悬挂指针等问题导致系统崩溃或不稳定。但如果正在编写一个图形渲染引擎，那么可能需要更多地关注如何优化数据处理和图形渲染算法，以提高系统的性能和渲染速度。

因此，C++ 高效编程守则并不是一成不变的，而是需要根据实际应用场景和使用的 C++ 特性来灵活调整和选择。同时，为了避免出现潜在的错误和问题，编写高效的 C++ 代码还需要遵循 C++ 的语言规范和标准。

2.2 C++次语言适用的场景

次语言种类	适用场景
C 语言	C 语言是一种广泛使用的高级编程语言，适用于开发系统软件、嵌入式软件、操作系统、网络协议栈等应用程序。
面向对象编程语言	面向对象编程语言适用于开发需要模拟现实世界中的对象和操作的应用程序，如图形界面程序、游戏、模拟器等。
泛型编程语言	泛型编程语言适用于需要编写通用算法和数据结构的应用程序，如 STL 中的容器和算法。
STL	作为一个应用框架，包含了非常多的容器与算法，且数据结构与算法是分离的，这使STL变得非常通用
并发编程语言	并发编程语言适用于需要在多个线程之间共享数据和资源的应用程序，如多线程计算、网络服务器、分布式系统等。
高级编程语言支持	高级编程语言适用于需要在运行时处理复杂的逻辑和数据结构的应用程序，如游戏引擎、编译器、图像处理等。

3.简单认识各个次语言的样子

3.1 C语言

计算输入两个数的和并输出结果：

#include <stdio.h>

int main() {
  int a, b, sum;
  printf("Enter two numbers: ");
  scanf("%d %d", &a, &b);
  sum = a + b;
  printf("Sum = %d\n", sum);
  return 0;
}

3.2 面向对象编程语言

定义一个名为 Rectangle 的类，表示矩形，包含了计算矩形面积和周长的方法：

#include <iostream>

class Rectangle {
public:
  Rectangle(double width, double height) : width_(width), height_(height) {}

  double area() const { return width_ * height_; }

  double perimeter() const { return 2 * (width_ + height_); }

private:
  double width_;
  double height_;
};

int main() {
  Rectangle rect(3.0, 4.0);
  std::cout << "Area: " << rect.area() << std::endl;
  std::cout << "Perimeter: " << rect.perimeter() << std::endl;
  return 0;
}

3.3 泛型编程语言

使用模板定义一个通用的 max 函数，可以比较两个值的大小并返回其中较大的一个：

#include <iostream>

template <typename T>
T max(T a, T b) {
  return a > b ? a : b;
}

int main() {
  int a = 3, b = 5;
  std::cout << "Max: " << max(a, b) << std::endl;
  double c = 2.5, d = 1.8;
  std::cout << "Max: " << max(c, d) << std::endl;
  return 0;
}

3.4 元编程语言

使用模板元编程计算斐波那契数列的第 n 项：

#include <iostream>

template <int n>
struct Fibonacci {
  static const int value = Fibonacci<n - 1>::value + Fibonacci<n - 2>::value;
};

template <>
struct Fibonacci<0> {
  static const int value = 0;
};

template <>
struct Fibonacci<1> {
  static const int value = 1;
};

int main() {
  const int n = 10;
  std::cout << "Fibonacci(" << n << "): " << Fibonacci<n>::value << std::endl;
  return 0;
}

3.5 STL

使用 vector 存储一组数，并进行排序：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
  std::vector<int> v = {5, 3, 1, 4, 2};

  std::sort(v.begin(), v.end());

  for (int x : v) {
    std::cout << x << " ";
  }
  std::cout << std::endl;
  
  return 0;
}

3.6 并发编程语言

使用线程计算从 1 到 100 的和：

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> sum(0);

void worker(int start, int end) {
  for (int i = start; i <= end; ++i) {
    sum += i;
  }
}

int main() {
  const int kThreadNum = 4;
  const int kRange = 100;

  std::thread threads[kThreadNum];

  int step = kRange / kThreadNum;
  for (int i = 0; i < kThreadNum; ++i) {
    int start = i * step + 1;
    int end = (i == kThreadNum - 1) ? kRange : (start + step - 1);
    threads[i] = std::thread(worker, start, end);
  }

  for (int i = 0; i < kThreadNum; ++i) {
    threads[i].join();
  }

  std::cout << "Sum: " << sum << std::endl;
  return 0;
}

该程序使用了 4 个线程，每个线程计算部分数据的和，最后将所有线程的计算结果加起来得到最终的和。在并发编程中，需要特别注意共享资源的访问和修改，避免出现数据竞争等问题。在上面的程序中，使用了 std::atomic 类型的变量 sum 来保证线程安全。

4.赠送高效C++编程小技巧

1. 选择合适的数据结构和算法：使用适当的数据结构和算法可以大大提高程序的效率。比如，对于需要频繁访问的数据，可以选择数组而不是链表；对于需要排序的数据，可以选择快速排序而不是冒泡排序。

2. 避免频繁的内存分配和释放：频繁的内存分配和释放会导致系统产生额外的开销，因此可以考虑使用对象池或者缓存等方式来优化内存分配和释放。

3. 使用引用和指针来传递大型对象：当传递大型对象时，传递指针或引用可以避免复制对象的过程，提高程序的效率。

4. 使用内联函数：内联函数可以避免函数调用的开销，直接将函数代码嵌入到调用处，提高程序的效率。

5. 优化循环结构：循环结构是程序中最常见的控制结构，因此在优化程序时，需要特别关注循环结构的效率。比如，可以避免在循环中使用过多的函数调用、避免使用过多的条件判断等。

6. 避免浪费计算资源：在程序中，有些计算可能会重复执行或者根本不需要执行。因此，需要避免无效的计算和重复的计算，减少程序的运行时间。

7. 使用多线程和并行计算：当程序需要处理大量数据或者需要进行复杂的计算时，可以考虑使用多线程和并行计算来提高程序的效率。

总的来说，要编写高效的 C++ 代码，需要深入了解 C++ 的语言特性和编程技巧，并根据实际应用场景来选择最佳实践和编程守则。同时，需要注重程序的可读性和可维护性，以确保程序的稳定性和可靠性。