为了C++20，C++标准委员会曾举办历史上规模最大的一次会议（180人参会），试图通过会议确定哪些特性可以加入新版本，我们也已经看到媒体爆料的部分新特性，比如Concepts、Ranges、Modules、Coroutines等，但大部分开发人员并不认可此次调整，并将部分新特性归结为“语法糖”。

不少网友看到上述特性纷纷在社交平台吐槽，表示不看好C++20版本的发布：

不仅国内如此，国外的一位游戏领域开发人员接连在社交平台发表看法，声明自己不看好C++20的新特性，并认为新版本没有解决最关键的问题，他通过使用毕达哥拉斯三元数组示例对C++20标准下的代码和旧版本进行对比，明确阐述自己对于C++20的态度。

毕达哥拉斯三元数组，C ++ 20 Ranges风格

以下是C++20标准下代码的完整示例：

// A sample standard C++20 program that prints
// the first N Pythagorean triples.
#include <iostream>
#include <optional>
#include <ranges>   // New header!
 
using namespace std;
 
// maybe_view defines a view over zero or one
// objects.
template<Semiregular T>
struct maybe_view : view_interface<maybe_view<T>> {
  maybe_view() = default;
  maybe_view(T t) : data_(std::move(t)) {
  }
  T const *begin() const noexcept {
    return data_ ? &*data_ : nullptr;
  }
  T const *end() const noexcept {
    return data_ ? &*data_ + 1 : nullptr;
  }
private:
  optional<T> data_{};
};
 
// "for_each" creates a new view by applying a
// transformation to each element in an input
// range, and flattening the resulting range of
// ranges.
// (This uses one syntax for constrained lambdas
// in C++20.)
inline constexpr auto for_each =
  []<Range R,
     Iterator I = iterator_t<R>,
     IndirectUnaryInvocable<I> Fun>(R&& r, Fun fun)
        requires Range<indirect_result_t<Fun, I>> {
      return std::forward<R>(r)
        | view::transform(std::move(fun))
        | view::join;
  };
 
// "yield_if" takes a bool and a value and
// returns a view of zero or one elements.
inline constexpr auto yield_if =
  []<Semiregular T>(bool b, T x) {
    return b ? maybe_view{std::move(x)}
             : maybe_view<T>{};
  };
 
int main() {
  // Define an infinite range of all the
  // Pythagorean triples:
  using view::iota;
  auto triples =
    for_each(iota(1),  {
      return for_each(iota(1, z+1), = {
        return for_each(iota(x, z+1), = {
          return yield_if(x*x + y*y == z*z,
            make_tuple(x, y, z));
        });
      });
    });
    // Display the first 10 triples
    for(auto triple : triples | view::take(10)) {
      cout << '('
           << get<0>(triple) << ','
           << get<1>(triple) << ','
           << get<2>(triple) << ')' << '\n';
  }
}

以下代码为简单的C函数打印第一个N Pythagorean Triples：

void printNTriples(int n)
{
    int i = 0;
    for (int z = 1; ; ++z)
        for (int x = 1; x <= z; ++x)
            for (int y = x; y <= z; ++y)
                if (x*x + y*y == z*z) {
                    printf("%d, %d, %d\n", x, y, z);
                    if (++i == n)
                        return;
                }
}

如果不必修改或重用此代码，那么一切都没问题。但是，如果不想打印而是将三元数组绘制成三角形或者想在其中一个数字达到100时立即停止整个算法，应该怎么办呢？

毕达哥拉斯三元数组，简单的C ++风格

以下是旧版本的C++代码实现打印前100个三元数组的完整程序：

// simplest.cpp#include <time.h>#include <stdio.h>
int main(){
    clock_t t0 = clock();

    int i = 0;
    for (int z = 1; ; ++z)
        for (int x = 1; x <= z; ++x)
            for (int y = x; y <= z; ++y)
                if (x*x + y*y == z*z) {
                    printf("(%i,%i,%i)\n", x, y, z);
                    if (++i == 100)
                        goto done;
                }
    done:

    clock_t t1 = clock();
    printf("%ims\n", (int)(t1-t0)*1000/CLOCKS_PER_SEC);
    return 0;
}

我们可以编译这段代码：clang simplest.cpp -o outsimplest，需要花费0.064秒，产生8480字节可执行文件，在2毫秒内运行并打印数字（使用的电脑是2018 MacBookPro，Core i9 2.9GHz，Xcode 10 clang）：

(3,4,5)
(6,8,10)
(5,12,13)
(9,12,15)
(8,15,17)
(12,16,20)
(7,24,25)
(15,20,25)
(10,24,26)
...
(65,156,169)
(119,120,169)
(26,168,170)

这是Debug版本的构建，优化的Release版本构建：clang simplest.cpp -o outsimplest -O2，编译花费0.071秒，生成相同大小（8480b）的可执行文件，并在0ms内运行（在clock（）的计时器精度下）。

接下来，对上述代码进行改进，加入代码调用并返回下一个三元数组，代码如下：

// simple-reusable.cpp#include <time.h>#include <stdio.h>
struct pytriples
{
    pytriples() : x(1), y(1), z(1) {}
    void next()
    {
        do
        {
            if (y <= z)
                ++y;
            else
            {
                if (x <= z)
                    ++x;
                else
                {
                    x = 1;
                    ++z;
                }
                y = x;
            }
        } while (x*x + y*y != z*z);
    }
    int x, y, z;
};
int main(){
    clock_t t0 = clock();

    pytriples py;
    for (int c = 0; c < 100; ++c)
    {
        py.next();
        printf("(%i,%i,%i)\n", py.x, py.y, py.z);
    }

    clock_t t1 = clock();
    printf("%ims\n", (int)(t1-t0)*1000/CLOCKS_PER_SEC);
    return 0;
}

这几乎在同一时间编译和运行完成，Debug版本文件变大168字节，Release版本文件大小相同。此示例编写了pytriples结构，每次调用next()都会跳到下一个有效三元组，调用者可随意做任何事情，此处只调用一百次，每次打印三联。

虽然实现的功能等同于三重嵌套for循环，但C++ 20标准下的代码让人感觉不是很清楚，无法立即读懂程序逻辑。如果C ++有类似coroutine的概念，就可能实现三元组生成器，并且和原始的for循环嵌套一样清晰：

generator<std::tuple<int,int,int>> pytriples()
{
    for (int z = 1; ; ++z)
        for (int x = 1; x <= z; ++x)
            for (int y = x; y <= z; ++y)
                if (x*x + y*y == z*z)
                    co_yield std::make_tuple(x, y, z);
}

C ++20 Ranges会让整段代码更加清晰吗？结果如下：

auto triples =
    for_each(iota(1),  {
        return for_each(iota(1, z+1), = {
            return for_each(iota(x, z+1), = {
                return yield_if(x*x + y*y == z*z,
                    make_tuple(x, y, z));
                });
            });
        });

多次return实在是让人感觉很奇怪，这或许不应该成为好语法的标准。

C++存在的问题有哪些？

如果谈到C++的问题，至少有两个：一是编译时间；二是运行时性能。虽然C++ 20 Ranges还未正式发布，但本文使用了它的近似版，即isrange-v3（由Eric Niebler编写），并编译了规范的“Pythagorean Triples with C ++ Ranges”示例：

// ranges.cpp#include <time.h>#include <stdio.h>#include <range/v3/all.hpp>
using namespace ranges;
int main(){
    clock_t t0 = clock();

    auto triples = view::for_each(view::ints(1),  {
        return view::for_each(view::ints(1, z + 1), = {
            return view::for_each(view::ints(x, z + 1), = {
                return yield_if(x * x + y * y == z * z,
                    std::make_tuple(x, y, z));
            });
        });
    });

    RANGES_FOR(auto triple, triples | view::take(100))
    {
        printf("(%i,%i,%i)\n", std::get<0>(triple), std::get<1>(triple), std::get<2>(triple));
    }

    clock_t t1 = clock();
    printf("%ims\n", (int)(t1-t0)*1000/CLOCKS_PER_SEC);
    return 0;
}

该代码使用0.4.0之后的版本，并用clang ranges.cpp -I. -std=c++17 -lc++ -o outranges编译，整个过程花费2.92秒，可执行文件为219千字节，运行在300毫秒之内。

这是一个非优化的构建，优化构建版本（clang ranges.cpp -I. -std=c++17 -lc++ -o outranges -O2）在3.02秒内编译，可执行文件为13976字节，并在1ms内运行。因此运行时性能很好，可执行文件稍大，编译时问题仍然存在。

C++20比简单版本的代码编译时间长近3秒

编译时是C ++的一个大问题，这个非常小的例子编译时间比简单版的C ++长2.85秒。在3秒内，现代CPU可以进行大量操作，比如，在Debug构建中编译一个包含22万行代码的数据库引擎（SQLite）只需要0.9秒。所以，编译一个简单的5行示例代码比运行完整的数据库引擎慢三倍？

在开发过程中，C ++编译时间一直是大小代码库的痛苦根源。他认为，C ++新版本应该把解决编译时问题排在第一位。但是，整个C++社区好像并不知道该问题，每个版本都将更多内容放入头文件，甚至放入必须存在于头文件的模板化代码中。

range-v3是1.8兆字节的源代码，全部在头文件中，因此，虽然使用C++ 20输出100个三元数组的代码示例只有30行，但加上头文件后，编译器最终会编译102,000行代码。在所有预处理之后，简单版本的C ++示例只有720行代码。

调试构建性能差

Ranges示例的运行时性能慢了150倍，这对于要解决实际问题的代码库而言，两个数量级的速度可能意味着不会对任何实际数据集起作用。该开发者在游戏行业工作，这意味着引擎或工具的Debug版本不适用于任何真实的游戏级别模拟（性能无法接近所需的交互级别）。

通过避免STL位（提交），可以让最终运行时快10倍，也可以让编译时间更快且调试更容易，因为微软的STL实现特别喜欢深度嵌套的函数调用。这并不是说STL必然不好，有可能编写STL实现在非优化版本中不会变慢10倍（如EASTL或libc ++那样），但由于微软的STL过度依赖深度嵌套，因此会变慢。

作为语言的使用者，大部分人不关心它是否正确发展！即便知道STL在Debug中太慢，宁愿花时间修复或者研究替代方案（例如不使用STL，重新实现需要的位，或者完全停止使用C ++）也不会花时间整理论文上报C++委员会，这太浪费时间。

其他语言如何？

这里简要介绍C＃中“毕达哥拉斯三元数组”实现，以下是完整C＃源代码：

using System;using System.Diagnostics;using System.Linq;
class Program
{
    public static void Main()
    {
        var timer = Stopwatch.StartNew();
        var triples =
            from z in Enumerable.Range(1, int.MaxValue)
            from x in Enumerable.Range(1, z)
            from y in Enumerable.Range(x, z)
            where x*x+y*y==z*z
            select (x:x, y:y, z:z);
        foreach (var t in triples.Take(100))
        {
            Console.WriteLine($"({t.x},{t.y},{t.z})");
        }
        timer.Stop();
        Console.WriteLine($"{timer.ElapsedMilliseconds}ms");
    }
}

就个人而言，C＃可读性较高：

var triples =
    from z in Enumerable.Range(1, int.MaxValue)
    from x in Enumerable.Range(1, z)
    from y in Enumerable.Range(x, z)
    where x*x+y*y==z*z
    select (x:x, y:y, z:z);

用C ++:

auto triples = view::for_each(view::ints(1),  {
    return view::for_each(view::ints(1, z + 1), = {
        return view::for_each(view::ints(x, z + 1), = {
            return yield_if(x * x + y * y == z * z,
                std::make_tuple(x, y, z));
        });
    });
});

C＃LINQ的另一种“数据库较少”的形式：

var triples = Enumerable.Range(1, int.MaxValue)
    .SelectMany(z => Enumerable.Range(1, z), (z, x) => new {z, x})
    .SelectMany(t => Enumerable.Range(t.x, t.z), (t, y) => new {t, y})
    .Where(t => t.t.x * t.t.x + t.y * t.y == t.t.z * t.t.z)
    .Select(t => (x: t.t.x, y: t.y, z: t.t.z));

在Mac上编译这段代码，需要使用Mono编译器（本身是用C＃编写的），版本5.16。mcs Linq.cs需要0.20秒。相比之下，编译等效的简单C＃版本需要0.17秒。LINQ样式为编译器创建了额外的0.03秒。但是，C ++却创造了额外的3秒。

一般来说，我们会试图避免大部分STL，使用自己的容器，哈希表使用开放寻址代替…甚至不需要标准库的大部分功能。但是，难免需要时间说服每一位新员工（尤其是应届生），因为C++20被称为现代C ++，很多新员工认为“新一定就是好”，其实并不是这样。

为什么C ++会这样？

该开发者表示不太清楚C++为什么会发展到现在这个地步。但他个人认为，C++社区需要学会“保持接近100％向后兼容的同时发展一种语言”。在某种程度上，现在的C++生态系统太专注于炫耀或证明其价值的复杂性，却并不易用。

在他的印象中，大多数游戏开发人员还停留在C++ 11、14或者17版本，C++20基本忽略了一个问题，无论什么被添加到标准库，编译时间长和调试构建性能差的问题没有解决都是无用的。

对于游戏产业而言，大部分传统技术是用C或C ++构建的，在很长一段时间内，没有出现可行的替代品（好在目前至少可以用Rust作为可能的竞争者），对C和C ++的依赖程度很高，需要社区的一些帮助和回应。

参考链接：http://aras-p.info/blog/2018/12/28/Modern-C-Lamentations/

创作场景

C++ 20 的悲叹，未出世就被群嘲“劝退”