CRTP-ed std::vectors的三向比较
是指使用CRTP（Curiously Recurring Template Pattern）技术对std::vector进行扩展，实现三向比较（Three-way Comparison）功能。
三向比较是指对两个对象进行比较时，返回三种可能的结果：小于、等于、大于。在C++20标准中，引入了三向比较运算符（<=>），用于简化对象之间的比较操作。
CRTP是一种模板元编程技术，通过在派生类中继承一个模板基类，并将派生类自身作为模板参数传递给基类，实现在编译期间生成派生类特定的代码。在这个问题中，CRTP用于对std::vector进行扩展，以支持三向比较。
CRTP-ed std::vectors的三向比较的优势在于可以方便地对std::vector进行比较操作，避免了手动编写比较函数的繁琐过程。通过使用CRTP技术，可以在编译期间生成特定的比较代码，提高了比较的效率。
应用场景：
- 数据库查询结果的排序：当使用std::vector存储数据库查询结果时，可以使用CRTP-ed std::vectors的三向比较功能对结果进行排序。
- 自定义数据类型的比较：当需要对自定义数据类型进行比较操作时，可以使用CRTP-ed std::vectors的三向比较功能简化比较代码的编写。
腾讯云相关产品和产品介绍链接地址： 腾讯云提供了丰富的云计算产品和服务，以下是一些相关产品和介绍链接地址：
- 云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 云数据库 MySQL 版（CDB）：https://cloud.tencent.com/product/cdb
- 云原生应用引擎（TKE）：https://cloud.tencent.com/product/tke
- 人工智能平台（AI Lab）：https://cloud.tencent.com/product/ailab
- 物联网开发平台（IoT Explorer）：https://cloud.tencent.com/product/iothub
- 移动应用开发平台（MPS）：https://cloud.tencent.com/product/mps
- 云存储（COS）：https://cloud.tencent.com/product/cos
- 区块链服务（BCS）：https://cloud.tencent.com/product/bcs
- 腾讯云元宇宙：https://cloud.tencent.com/solution/virtual-universe
请注意，以上链接仅供参考，具体产品和服务详情请参考腾讯云官方网站。
相关·内容
所有基本比较(<、<=、==、!=、>=、>)都有一个关联的函数对象(std::less、std::less_equal、std::equal_to、std::not_equal_to、std::greater_equal、std::greater)。 宇宙飞船操作符<=>是否有类似的函数对象？如果没有，为什么不将其添加到标准库中？
浏览 14提问于2020-09-21得票数 20
回答已采纳
1回答
纠正我的次优二分搜索
、、、
我的二进制搜索是为了在std::vector中找到有序插入的位置。然而，在我看来，它似乎正在执行一个(或多个？)太多的比较找不到那个位置。尤其是末尾的三元组。我是不是设计错了？需要说明的是，我没有注意到输出中有任何错误。
template<typename T>
size_t find(std::vector<T> data, T value) //returns position value should be inserted at
{
size_t start = 0;
size_t end = data.size();
if (!end) return
浏览 0提问于2013-01-29得票数 0
回答已采纳
我试图在sort中使用lambda函数，但得到了“分段错误”错误。我设法将代码简化为以下内容：
#include <iostream>
#include <algorithm>
int main()
{
const int len = 18;
int intArr[len];
for (int i=0;i<len;i++) intArr[i]=1000+i;
// The following is expected to sort all but the last element of the array
std::sort(intArr,
浏览 0提问于2011-10-14得票数 30
回答已采纳
根据，如果第一个arg小于第二个arg，则任何Compare类型函数都应该返回true，否则就返回false。这种命名的需求被用于许多标准算法，如std::sort、std::map、std::set等。然而，它们中的许多都需要判断两个元素是否“相等”。正如引用所述，标准库确定了a == b iff !comp(a, b) && !comp(b, a)。显然，判断等值需要两倍的时间。
正如我们所知道的，std::string::compare方法返回一个int值，它分别用负值、零值和正值表示“较少”、“相等”和“更大”。这似乎是一个好主意，在一个操作中表达两个值之间的三种可能的
浏览 7提问于2022-06-23得票数 3
1回答
为什么我仍然可以从vectors[0]获得值，即使我已经在第一步就已经pop_back()了？
我猜现在我的vectors是空的，并通过调用empty()来检查它
#include <iostream>
#include <vector>
struct Vector2 {
int x, y;
Vector2(int _x, int _y)
: x(_x)
, y(_y) {}
Vector2(const Vector2& vec)
: x(vec.x)
, y(vec.
浏览 2提问于2020-03-29得票数 2
回答已采纳
#include <compare>
struct A
{
int n;
auto operator<=>(A const& other) const
{
if (n < other.n)
{
return std::strong_ordering::less;
}
else if (n > other.n)
{
return std::strong_ordering::greater;
浏览 3提问于2021-07-02得票数 55
回答已采纳
1回答
我有一个paramaters.txt文件，其中包含OpenGL代码的一些参数，我需要读取它，并将它们放在一个矩阵中。
parameters.txt：
[6.0,6.0,9.0,5.0,1.0,0.6,0.4]
[3.0,1.0,3.0,6.0,1.0,0.4,0.6]
在这里，我做了一些代码来将.txt中的项转换为整数(当我使用整数时)
弗雷流：
void selector() {
int numberOfObjects = 0;
char path[100];
std::string my_list;
//std::vector<std:
浏览 2提问于2019-11-29得票数 1
回答已采纳
下面的代码调用运算符<=>两次，参数颠倒。但是为什么呢？
GCC 10.2和clang 12似乎都在使用libstdc++-10，它确实提供了运算符<=>，所以看起来并不是缺少标准库支持的情况，我的代码一定是不正确的。如何修复它？
#include <tuple>
#include <compare>
#include <iostream>
struct X {
int i;
auto operator <=>(X const& other) const {
std::cout &
浏览 19提问于2021-02-13得票数 8
回答已采纳
2回答
我正在使用单元测试框架，并且我想比较一个双精度向量。此建议使用近似来比较浮点/双精度值，但这不适用于它们的向量。有什么方便的方法可以做到这一点吗？
编辑:示例
使用以下代码：
#define CATCH_CONFIG_MAIN
#include "catch.hpp"
TEST_CASE("Compare Vectors", "[vector]") {
std::vector<int> vec1 = {0, 1, 2, 3};
std::vector<int> vec2 = {0, 1, 2, 4};
浏览 2提问于2017-01-26得票数 3
1回答
我做了一个函数，估计三维点云的法向量，在200万大小的云上运行需要很长时间。我想通过同时在两个不同的点上调用相同的函数来多线程，但是它没有工作(它创建了数百个线程)。以下是我尝试过的：
// kd-tree used for finding neighbours
pcl::KdTreeFLANN<pcl::PointXYZRGB> kdt;
// cloud iterators
pcl::PointCloud<pcl::PointXYZRGB>::iterator cloud_it = pt_cl->points.begin();
pcl::PointCloud
浏览 2提问于2016-04-25得票数 0
回答已采纳
2回答
我有一个问题，我已经坚持了一段时间，试图使我的代码更高效。我已经创建了一个向量类，需要用它做一些基本的计算。使用向量库是不可能的，我需要创建自己的。我目前的问题在数学的最后阶段。我可以输入第一个和第二个向量的值，但是把它们加在一起，就可以得到完全随机的数字。我张贴我的头文件和我的cpp文件-任何帮助将不胜感激！！
Vectors.h
#include <math.h>
#include <iostream>
class Vectors
{
public:
Vectors(void);
~Vectors(void);
Vectors(double
浏览 0提问于2016-04-16得票数 0
回答已采纳
对于i7-6700K上的一个小的OpenMP基准测试，我编写了以下代码：
#include <iostream>
#include <omp.h>
#include <vector>
#include <chrono>
constexpr int bench_rounds = 32;
int main(void) {
using std::chrono::high_resolution_clock;
using std::chrono::duration_cast;
using std::chrono::duratio
浏览 1提问于2021-09-16得票数 2
回答已采纳
通过C++20概念和三向比较，我创建了自己的Map，如下所示：
template<
typename TKey,
typename TValue,
std::strict_weak_order<TKey, TKey> KeyComparer = std::compare_three_way, // Error: template constraint not satisfied
typename PairAllocator = std::allocator<KeyValuePair<TKey, TValue>>
>
浏览 3提问于2020-11-28得票数 4
回答已采纳
1回答
如果我有一个包含N个相同大小的vectors的类。我将如何实现一个标准迭代器模板，该模板将在1和N个向量之间迭代。我写了一个演示这个问题的小例子。
#include <bitset>
#include <tuple>
#include <type_traits>
#include <vector>
//Since std::get<>() for types isn't in c++11, I use this meta-function to determine the index
//of a Type in a lis
浏览 1提问于2016-11-30得票数 1
回答已采纳
伙计们我的问题很简单..。我想为不同的值类型构造一个getter和setter。基本功能重载，但使用getter和setter。我试过像这样
#include <iostream>;
class Vectors {
public:
Vectors() {};
Vectors(int a, int b) {
x = a, y = b;
}
int getX() {
return x;
}
int getY() {
return y;
}
float getX() {
浏览 1提问于2016-04-21得票数 0
回答已采纳
我想知道为什么在qsort() {C版本}和std::sort()中指定比较函数有两种完全不同的方法。
qsort需要如下所示的比较函数:我不知道为什么它需要三种返回值-1，0，+1。
int comp(int *x, int *y){
return *x - *y;
}
而std::sort()的比较函数，在我看来更一致，因为它是以函数的形式编写的，它遵循一个不变式。也就是说，如果x小于y函数返回true，则x相对于y处于正确位置。
bool comp(int x, int y){
return x < y;
}
为什么当返回bool (或带有两个值
浏览 5提问于2013-08-01得票数 5
回答已采纳
4回答
操作者超载
、、
我对一个关于操作符重载的话题感到困惑。请参阅下列代码：
#include <iostream>;
class Vectors {
public:
int x, y;
Vectors() {};
Vectors(int a,int b) {
x = a, y = b;
}
Vectors operator+(Vectors aso) {
Vectors brandNew;
std::cout << "ASO X " << aso.x << st
浏览 1提问于2016-04-21得票数 1
回答已采纳
3回答
令我惊讶的是，我遇到了另一个像这样的麻烦。
考虑一个简单的不区分大小写的密钥类型，用于例如std::set或std::map。
// Represents case insensitive keys
struct CiKey : std::string {
using std::string::string;
using std::string::operator=;
bool operator<(CiKey const& other) const {
return boost::ilexicographical_compare(*thi
浏览 2提问于2021-03-05得票数 44
4回答
我想在对象数组上构造嵌套循环，具有相当复杂的数据结构。因为我使用数组，所以我想使用它们的迭代器。在我得到了意想不到的结果后，我将问题归结为以下代码片段，它显示了我的迭代器在我期望它们不同时是相等的：
vector<int> intVecA;
vector<int> intVecB;
intVecA.push_back(1);
intVecA.push_back(2);
intVecB.push_back(5);
intVecB.push_back(4);
Foo fooOne(intVecA);
Foo fooTwo(intVecB);
vector<in
浏览 1提问于2013-04-19得票数 1
回答已采纳
3回答
#include <iostream>
#include <math.h>
using namespace std;
class Vectors
{
public:
Vectors(void);
float X, Y;
Vectors (float X, float Y);
float magnitude();
Vectors normalize();
};
Vectors::Vectors (float x_value, float y_value) {
X = x_value;
Y = y_val
浏览 2提问于2015-10-08得票数 0
是否可以在stl算法中使用glm：：gtx：：比较中定义的运算符？
具体来说，我有这样的代码：
std::vector<glm::ivec3> vecA, vecB; // vectors with content
bool result = std::equal(vecA.begin(), vecA.end(), vecB.begin());
默认情况下，这会失败，因为找不到operator==。
浏览 0提问于2010-10-08得票数 4
回答已采纳
1回答
我有一个将静态Eigen向量转换为字节向量的函数： template<typename T, int N>
static std::vector<uint8_t> toBytes(std::vector<Eigen::Matrix<T, N, 1>> const & vectors)
{
std::vector<uint8_t> bytes;
uint8_t const * rawData = reinterpret_cast<uint8_t const *>(vectors.data());
浏览 14提问于2019-06-21得票数 1
回答已采纳
我正在实现Prims算法。我有一个边向量和它们的权重。问题是，插入后，队列不会根据边的权重而保持递增顺序。
有关守则如下：
struct weightcomp // To be used solely for priority Queue...
{
bool operator()(Edge &E1, Edge &E2)
{
if(E1.weight > E2.weight)
return true;
}
};
std::priority_queue<Edge,std::vector<Edge&g
浏览 3提问于2015-04-29得票数 0
回答已采纳
我正在寻找一种有效的方法来获得两个std::vectors之间的差异。它们包含的对象没有任何自然的顺序；我能做的最好的事情就是测试是否相等。这似乎排除了std::set_difference选项。
有比比较两个嵌套迭代器中的对象更好的解决方案吗？
浏览 2提问于2013-03-22得票数 0
1回答
我在VHDL语言中有一段代码，这让我不确定它是否正确:a和b是std_logic_vectors。c1和c0是std_logic。这是正确的书写吗？尤其是"c1 = '1‘和c0 = '0'“这一部分让我头疼。 if unsigned(a) > unsigned(b) then
assert(c1 = '1' and c0 = '0') 编辑:下面是一个更大的代码段： signal a: std_logic_vector(3 downto 0);
signal b: std_logic_vector
浏览 178提问于2019-12-29得票数 2
回答已采纳
6回答
我需要一个算法或标准库函数来比较两个向量元素，如下所示：
class Utility
{
template <class T>
static bool CheckIfVectorsEquivalent( const std::vector<T> & Vec1,
const std::vector<T> & Vec2)
{
// ???
}
};
在以下规范下工作：
std::vector<int&g
浏览 0提问于2012-05-09得票数 5
回答已采纳
2回答
为什么神经网络的准确性差？
、、、、
我有一个由43个示例(数据点)和70000个特性组成的数据集，这意味着我的数据集矩阵是(43x70‘000)。标签包含4个不同的值(1-4)，即有4个类。
现在，我已经做了一个深度信念网络/神经网络分类，但我只获得了25%左右的准确性(机会水平)与休假一次交叉验证。如果我使用kNN，支持向量机等，我将获得80%以上的准确率.
我使用了DeepLearnToolbox for Matlab ()，并从工具箱的自述文件中改编了深度信念网络的例子。我尝试过不同数量的隐藏层(1-3)和不同数量的隐藏节点(100,500，.)以及不同的学习速度、动量等，但准确性仍然很差。特征向量被缩放到0,1，因为工具
浏览 4提问于2015-06-17得票数 0
我正在对一些简单的数值操作进行计时，以决定如何(即使用什么库中的工具)来实现计算密集型模拟。下面的代码使用(1) MTL4版本4.0.9486 (不包括BLAS)、(2) std::vectors和std::inner_product以及(3) std::valarray来计算向量的两个内积之和。我选择了这个特定形式的玩具示例，因为它似乎是MTL4 4表达式模板的理想基础。
把所有事情缩小到一个问题上，下面的比较是公平的，还是(无意中)将这三种方法中的任何一种置于不利地位？我对(2)比(1)更快感到有点惊讶。当然，整体模拟是否会更快是另一回事。
如果有人对更彻底的测试有任何建议，这些建议可能会
浏览 3提问于2014-04-08得票数 0
回答已采纳
我是C++新手
class BlenderMesh{
public:
std::vector<double[3]> vertex_vectors;
std::vector<double[3]> normal_vectors;
std::vector<double[2]> uv_vectors;
std::vector<std::string> texture_list;
std::vector<int[6]>
浏览 0提问于2016-10-16得票数 0
我正在寻找关于windows上.net开发的三向合并工具的建议。作为一名软件开发人员，我主要使用C#、SQL、Javascript和AngularJS，我通常使用kdiff3，但听说过一些非常好的东西。我很高兴为一个好的工具支付一些钱，所以“无与伦比”的60美元是可以的。但我想知道它们有何不同，或者是否有更好的选择。我已经尝试过了，但基本上没有花力气去研究我从kdiff那里得到的东西。
在过去，我发现kdiff很好，但在做更复杂的合并时却不是很直观，只是没有比它更漂亮。但是，例如，我不知道他们的比较算法的聪明之处，也不知道他们的一些更高级的特性如何比较。付点钱你能得到什么？
大多数情况下，我将
浏览 0提问于2016-06-02得票数 4
进一步这个问题：，但这两个向量具有不同的类型。
我正在尝试根据std::string类型的另一个向量对具有struct Item类型的向量进行排序。为此，我使用了struct Item的一个元素(类型为std：：string的ID)，并将其与字符串向量进行比较。
struct myCompareStruct
{
std::vector<std::string> all;
std::vector<item> special;
myCompareStruct(const std::vector<std::string>& a, c
浏览 1提问于2013-10-20得票数 0
1回答
我有一个关于共享指针的快速问题，因为我正面临一个与共享指针相关的问题。我有一个名为Cube的共享指针，它有一个Vector3d的共享指针向量。
我想要做的是创建另一个Cube对象，该对象具有相同的 Vector3d 共享指针向量，因此它们具有相同的Vector3d向量。但是，当我这样做时，它会为第二个Cube对象在向量中创建对每个Vector3d的引用。这意味着，每当我更改第二个立方体中的点时，它也会更改第一个立方体中的所有Vector3d。
立方体类：
class Cube
{
public:
Cube();
~Cube();
std::vector<std::shared_ptr&l
浏览 1提问于2018-02-04得票数 0
回答已采纳
2回答
我是C++的新手。每当我试图从向量中比较字符串和字符串时，它都会给出一个错误。我列举了以下两个例子。这一切为什么要发生？
#include <iostream>
#include <vector>
#include <string>
int main() {
std::string vowels = ("aeiou");
std::string whale_talk = "turpentine and turtles";
std::vector<std::string> result;
for (
浏览 11提问于2022-12-01得票数 0
1回答
对于那些不熟悉多态内存资源(PMR)的人，
“类std::pmr::monotonic_buffer_resource是一个特殊用途的内存资源类，它只在资源被破坏时才释放所分配的内存。在内存被用来构建几个对象并立即释放的情况下，它用于非常快的内存分配。”
因此，如果析构函数的唯一目的是释放内存，那么在单调的缓冲区资源上调用它是没有意义的：
auto mbr = std::make_unique<std::pmr::monotonic_buffer_resource>();
auto vectors = std::pmr::vector<std::pmr::vect
浏览 2提问于2021-01-04得票数 1
回答已采纳
如果使用默认实现制作virtual C++20三向比较操作符<=>，那么编译器会静默地再生成一个虚拟operator==，可以通过在子类中重写它来显示：
struct A {
virtual std::strong_ordering operator <=>(const A &) const = default;
};
struct B : A {
virtual bool operator==(const A&) const noexcept override;
};
所有三大编译器都是这样运行的，演示：
这是标准所规定的，还是仅仅
浏览 2提问于2021-09-06得票数 10
回答已采纳
我有一个现有的算法，我需要优化它，如果可能的话。在这个算法中改变很多并不是目前的选择。algoritm与std::vector< std::vector<unsigned char> >实例一起工作。看起来是这样的：
typedef std::vector<unsigned char> internal_vector_t;
std::vector< internal_vector_t > internal_vectors;
while (fetching lots of records) {
internal_vector_t tmp;
浏览 22提问于2012-02-15得票数 5
回答已采纳
下面是我的.gitconfig中的设置，但当我合并时，我只在Araxis中看到两个窗格合并。激活三向合并的配置是什么？
[mergetool "araxis"]
path = C:\\Programs\\Tools\\Araxis\\Araxis Merge\\compare.exe
浏览 2提问于2016-12-22得票数 3
4回答
引言
我有一个代码，用integer值填充向量，并将其推入指向向量的向量，如下所示：
std::vector<std::vector<int>*> set_of_vectors;
for(int i = 0; i < 10; i++)
{
//initialize vector
std::vector<int> pos_vector;
//fill it with 0s
pos_vector.resize(10, 0);
//fill it with integers
fill_vec
浏览 4提问于2016-04-18得票数 1
回答已采纳
在我的矩阵实现中，我使用向量向量作为私有成员。我重载了ostream操作符，所以我可以从我的矩阵中打印所有的值。在下面的代码中，我使用第一个for_each来迭代我的矩阵的“行”。在lambda中，我在这一行的末尾指定一个参数(矩阵“列”)作为向量的引用：
std::for_each(p_matrix.m_vector_of_vectors.begin(), p_matrix.m_vector_of_vectors.end(), [& p_out] (std::vector<int> & el)
这会导致错误。这是完整的代码：
#include <iostre
浏览 0提问于2019-02-08得票数 2
回答已采纳
对于其他std类型，例如std::set，是否存在与等效的？我正在寻找一个内置的算法，它可以只做一次比较，并给出一个类似于-1，0，1的值分别小于，相等，大于。
浏览 0提问于2018-04-24得票数 0
回答已采纳
2回答
我正在尝试从std::tuple (原因：)创建一个向量元组，并提出了下面的代码。
谁能想到一个更优雅，更少冗长的解决方案呢？PS:我被C++14编译器困住了.
template<std::size_t N, class T, template<class> class Allocator>
struct tuple_of_vectors {};
template<class T, template<class> class Allocator>
struct tuple_of_vectors<1, T, Allocator>
{
浏览 4提问于2022-01-06得票数 1
回答已采纳
问题在代码中：
template<typename... Ts>
struct TupleOfVectorsOfVectors {
std::tuple<std::vector<std::vector<Ts>>...> tuple;
TupleOfVectorsOfVectors () {
//Here we already have a tuple of empty vectors.
//Question: How can I loop through those vectors
//and push_back
浏览 2提问于2013-05-05得票数 2
回答已采纳
1回答
将n个向量组合成一个n元组向量
、、、、
我在想一个有签名的函数
template<typename ...Ts>
std::vector<std::tuple<Ts...>> join_vectors(std::vector<Ts>&&...) {
//...
};
但是，如果更普遍地接受任何可迭代的方法，而不是只接受std::vector，那就更好了。可能会有这样的签名？
template<template<typename> typename C, typename ...Ts>
C<std::tuple<Ts...>
浏览 0提问于2020-11-24得票数 3
回答已采纳
当类型是一堆std::vector<T>时，我需要专门化一个多样化的模板。到目前为止，我的情况如下
#include <iostream>
#include <vector>
#include <type_traits>
template<typename... Ts>
struct is_vector{
is_vector(Ts&...){};
static void print() {std::cout << "not vectors" <<std::endl;}
浏览 14提问于2022-05-28得票数 2
3回答
这段代码：
#include <vector>
#include <string>
#include <iostream>
class MyClass
{
public:
MyClass(const std::vector<std::vector<std::string>> & v)
{
std::cout << "Vector of string vectors size: " << v.size() << "\n";
for (
浏览 0提问于2018-04-23得票数 18
下面的代码计算特征向量并存储在矩阵中，如何访问第一列第一元素？
Eigen::Matrix3f eigen_vectors;
pcl::eigen33 (covariance_matrix, eigen_vectors, eigen_values);
std::cout << "eigenvector:"<<eigen_vectors<<std::endl;
浏览 3提问于2015-03-03得票数 0
回答已采纳
2回答
我有两个std：：向量，一个浮点数，一个整数:A和B。
A = [5,3,1,2]
B = [0.1, 0.2, 0.3, 0.4]
我希望对A进行排序，并在B中保持相同的1-1。因此，结果应该如下所示：
A = [1,2,3,5]
B = [0.3, 0.4, 0.2, 0.1]
为了方便起见，我使用了python/js约定，但这些都是C++ std::vectors。我在考虑只做一个元组结构，并把它们打包成std:vector of tuple，重载排序比较器。有没有更懒的方式来做这件事？
浏览 0提问于2018-08-19得票数 3
1回答
int main()
{
map<int,string> my_map;
vector<map<int,string> > v_temp;
vector< vector<map<int,string> > > vectors;
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 2; j++)
{
my_map.insert(make_pair(1,"sea&
浏览 1提问于2020-05-30得票数 0
回答已采纳
3回答
我在vecOfVec中存储了200个大小从1到4000000的向量。我需要将这些向量与一个大小为9000+元素的向量"vecSearched“相交。我试着用下面的代码做同样的事情，但是使用perf工具，我发现我正在做的交叉点是我代码中的瓶颈。有没有什么方法可以让我进行有效的交叉口？
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, char** argv) {
vector<vector<
浏览 0提问于2015-06-26得票数 6
简单任务:我有这两种类型
struct type_a{
int member;
};
struct type_b{
int member;
};
我想使用这个新的C++20宇宙飞船op，每个人都说它很酷，可以写type_a{} == type_b{}。我没能做到。即使我在它们之间编写operator<=>，我也只能调用type_a{} <=> type_b{}，而不是简单的比较。这让我感到困惑，就像一个类一样，三向比较也定义了所有其他类。
替代配方？如何使它成为std::three_way_comparable_with<type_a, type_b
浏览 6提问于2022-01-13得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
