使用模板重载+运算符
使用模板重载+运算符可以实现在C++中实现运算符重载，并且可以应用于不同的数据类型。模板重载是指在C++中使用模板来实现函数或类的重载，可以实现对不同数据类型的处理。运算符重载是指在C++中使用特殊的函数来实现运算符的重载，可以使得自定义的数据类型也能够使用运算符。
模板重载+运算符的优势在于可以实现对不同数据类型的处理，并且可以使得自定义的数据类型更加灵活和易于使用。应用场景包括在自定义数据类型中实现运算符的重载，以及在模板函数和类中实现重载。
推荐的腾讯云相关产品和产品介绍链接地址：
- 腾讯云云服务器：https://cloud.tencent.com/product/cvm
- 腾讯云数据库：https://cloud.tencent.com/product/cdb
- 腾讯云存储：https://cloud.tencent.com/product/cos
- 腾讯云容器服务：https://cloud.tencent.com/product/tke
- 腾讯云云原生：https://cloud.tencent.com/product/tke
以上是腾讯云相关的产品和产品介绍链接地址，可以根据需要进行选择。
相关·内容
代码如下：
#include <iostream>
int main()
{
std::cout << 'a'; // a
operator << (std::cout, 'a'); // a
std::cout.operator << ('a'); // 97
}
使用命令编译：
g++.exe -Wall -g -Wall -std=c++11 -c <cpp file> -o <o file>
g++.exe <exe file>
浏览 7提问于2021-03-06得票数 1
2回答
在下面的代码中，我演示了一个操作符重载的示例：
#include <iostream>
using namespace std;
template <typename T>
class A
{
public:
A() {};
A( T &obj) {value = obj;};
~A() {};
T value;
template <typename E>
A<T>& operator = (const A<E> &obj)
{
co
浏览 0提问于2012-07-10得票数 2
回答已采纳
1回答
是否可以为重载运算符编写lambda表达式？
例如，我有以下结构：
struct X{
int value;
//(I can't modify this structure)
};
X需要==算子
int main()
{
X a = { 123 };
X b = { 123 };
//[define equality operator for X inside main function]
//if(a == b) {}
return 0;
}
==操作符可以定义为bool operator==(const X& lh
浏览 2提问于2018-04-24得票数 5
回答已采纳
2回答
我是C++新手，我的问题可能看起来很简单。我不能理解这些代码：
template<typename a, typename b>
bool operator < (const Pair<a,b> &op1 , const Pair<a,b> &op2)
{
return (op1.first() < op2.first())
};
运算符似乎是一个函数，它的输出类型是bool。那么这个“模板”是用来做什么的呢？因为这个模板是在类定义之前定义的。
template<typename a, typename b
浏览 1提问于2013-06-11得票数 1
回答已采纳
1回答
我对超载规则有点困惑，
假设有以下的文字运算符，
unsigned long long operator "" _xx(unsigned long long cooked_literal_int); //1
unsigned long long operator "" _xx(const char * raw_literal_string); // 2
unsigned long long operator "" _xx(long double cooked_literal_double); // 3
如果同时定义了1，2，&3，则超载是
浏览 5提问于2010-12-08得票数 2
回答已采纳
3回答
我想让我的班里的operator<<超负荷。我应该将这个重载的定义添加到std命名空间中吗？(因为ostream operator<<是std名称空间的一部分)，还是应该将它留在全局命名空间中？
简言之：
class MyClass {
};
namespace std {
ostream& operator<< ( ostream& Ostr, const MyClass& MyType ) {}
}
或
class MyClass {
};
std::ostream& operator<< (
浏览 0提问于2010-09-02得票数 17
回答已采纳
我不知道如何在复制构造函数中或在赋值构造函数中将int转换为double。有可能吗？该怎么做呢？
template <typename T>
class Container {
public:
Container() { //... }
Container(const Container& y) { //... }
Container& operator=(const Container& y) { //... }
~Container() { //... }
private:
// ...
};
int main(
浏览 0提问于2019-06-18得票数 3
回答已采纳
2回答
C++标准专家的几个相关问题。
传入的C++20 模板lambdas ()。
所以而不是
auto x = [](auto x, auto y){ return x+y; };
我们可以如下所示指定模板参数
auto x = []<typename T>(T x, T y){ return x+y; };
到现在为止还好。
第一个问题:在模板lambdas中，显式模板参数只能从参数中推断，还是可以添加非推导的模板参数？
阅读P0428r1我没有看到任何明确的限制，但我也没有看到非推导模板参数的例子。
在第一种近似下，我假设没有推导的模板参数是合法的，因为我看到了以下愚蠢的代码
in
浏览 3提问于2020-01-04得票数 8
回答已采纳
2回答
具有包装随机访问的C++向量？
、、、、
我真正想要的是C++中的容器类，除了[]操作符具有包装行为之外，它在所有方面都与STL类非常相似。例如：
vector<int> myVec;
myVec.push_back(5);
myVec.push_back(10);
myVec.push_back(15);
cout << myVec[ 5] << endl; // would output 15
cout << myVec[ 1] << endl; // would output 10
cout << myVec[-2] << endl;
浏览 0提问于2016-07-12得票数 4
1回答
我尝试找出什么时候应该使用C++20模板约束。
目前，我使用约束只是为了消除模板重载的歧义。
然而，还有更多的模板没有被重载。实际上，他们中的所有人都对模板类型的功能有隐含的期望。
例如，让我们假设一个函数模板，它隐式地期望一个容器类型，并通过调用T::size()方法和使用T::operator[]操作符访问该容器。通常，如果传递的类型没有提供T::size()方法和/或T::operator[]，我会得到一个编译错误。不过，我仍然可以添加显式约束来表达所需的功能。
在哪些情况下，依赖隐式编译错误而不是显式约束是致命的？除了将约束作为文档的一部分使用之外，显式约束与隐式要求相比还有什么优势？
浏览 0提问于2020-05-23得票数 1
我有一个从枚举创建的类，这个枚举可以在将来的任何时候测试，无论它是否通过，都会返回一个布尔值，例如：
ConditionObject cnd(CondIsTuesday);
door.setOpenCondition(cnd);
然后门有一个条件，它可以用来确定它的状态。
然而，我现在希望重载这个条件类的&&和||运算符，这样它们就可以链接在一起，并以正常布尔逻辑所期望的方式工作。例如，使以下操作成为可能：
ConditionObject cnd(ConditionObject(CondIsTuesday) || (ConditionObject(CondIsThursday)
浏览 2提问于2011-07-15得票数 4
回答已采纳
考虑下面的类：
class Test
{
public:
Test( char );
Test( int );
operator const char*();
int operator[]( unsigned int );
};
当我使用它时：
Test t;
Test& t2 = t[0];
我得到了一个编译器错误，它不能确定使用哪个operator[]。MSVC和Gcc都是。不同的错误。但问题是一样的。
我知道发生了什么。它可以从int或char构造测试，它可以使用Test::operator[]，也可以转换为const char*并使用构建的cha
浏览 0提问于2012-10-31得票数 2
回答已采纳
1回答
我尝试编写一个通过索引访问容器中的元素的类。因此，我将能够重新路由指向的容器(但这对于我当前的问题并不重要)。它将帮助我摆脱复杂的复制构造函数。
这个类应该表现为一个数字(即索引)和一个指针(即它所指向的指针)。因此，我有转换。然而，我得到了编译器错误：
In instantiation of 'class paxRef<Dog&, std::vector<Dog> >':
34:47: required from here
13:5: error: forming pointer to reference type 'Dog&
浏览 3提问于2016-11-07得票数 0
3回答
我没有看到任何解决我的特定代码问题的东西。
我在一个类中有一个bool函数；bool函数名为：
bool Triplet::operator ==(const Triplet& operand)const {
if( (data[0] == operand.data[0]) &&
(data[1] == operand.data[1]) &&
(data[2] == operand.data[2]))
return true;
...
我试图在Main中调用它，但在
浏览 2提问于2010-04-21得票数 1
回答已采纳
通常，您可以比较字符串。
if (var1 == "a string") ...
但当我使用转换操作符声明自己的类时，如下所示：
class my_type {
operator std::string() const { ... };
....
}
现在是这样：
std::string var1("a string");
my_type x("a string");
if (x == "a string") ....
if (x == var1) ....
不工作..即..。
error: no match
浏览 3提问于2012-09-11得票数 3
回答已采纳
所以我想我可能想过了，但我想知道是否有人能澄清为什么下面的语句在给定的代码中有效
f->hello();
这是密码
struct bar
{
void hello()
{
std::cout << "Hello World";
}
};
struct foo
{
bar* f;
foo() {
f = new bar();
}
~foo() {
delete f;
}
bar* operator->() {
ret
浏览 0提问于2018-07-29得票数 3
回答已采纳
2回答
class Test {
public:
operator string() {
return string{"TEST!"};
}
};
int main() {
cout << Test{};
}
我原以为Test对象将被隐式转换为字符串和输出，但它给了我错误：
error: cannot bind 'std::ostream {aka std::basic_ostream<char>}' lvalue to 'std::basic_ostream<char>&&a
浏览 2提问于2013-08-09得票数 1
回答已采纳
1回答
我已经在一些地方看到了这种情况，为了确认我没有疯，我。显然，这也可以有其他的风格，比如operator+ <>。
然而，我在任何地方看到的都没有提到它是什么，所以我想我应该问一下。
这不是谷歌operator<< <>(最容易的事情:-)
浏览 0提问于2010-06-10得票数 4
回答已采纳
我已经看过这篇，它谈到了使用这种方法进行比较：
struct thing
{
int a;
char b;
bool operator<(const thing &o) const
{
return a < o.a;
}
};
priority_queue<thing> pq;
另一方面，其他人使用的方法如下：
struct Time {
int h;
int m;
int s;
};
class CompareTime {
public:
bool ope
浏览 1提问于2013-06-23得票数 0
1回答
不完整类型的标准容器
、、、
我在容器和不完整的类型上遇到了一点小问题。
我有这样的代码：
template<typename T>
class IncompleteType
{ /*Class Definition*/ }
在另一个类上，我想使用一个不完整类型的向量。这个类将c风格的结构序列化为字符串，所以无论我提供什么类型，其行为都是相同的。
然而，当我这样做的时候：
std::vector<IncompleteType>
或者这样：
std::vector<IncompleteType*>
编译器抱怨我没有为模板类提供参数列表。
我想做的是这样的：
IncompleteType&l
浏览 1提问于2018-02-16得票数 1
auto f1 = []<typename T>(T) { return T{}; };
auto f2 = []<typename T>() { return T{}; };
int main()
{
f1(1); // ok
f2<int>(); // err: expected primary-expression before 'int'
}
为什么C++20不允许使用显式类型调用泛型lambda？
浏览 8提问于2021-04-24得票数 8
回答已采纳
2回答
如何选择特定的函数重载？
、、、
我希望将重载操作符传递给一个函数，该函数无法确定应该使用哪两个重载。
// This works, not overloaded:
chai.add(chaiscript::fun(&HttpRequest::operator+), "+");
// This does not, overloaded:
chai.add(chaiscript::fun(&(
std::map<std::string,std::string>::operator[]), "[]");
chaiscript：：can需要一个泛型参数，但它无法确定
浏览 5提问于2014-08-03得票数 0
回答已采纳
以下代码段(从实际程序中简化)生成以下内容：error: no viable overloaded '|='
class CMyInt
{
int mValue;
public:
operator int() { return mValue; }
void operator=(int &value) { mValue = value; }
};
template<class T>
class CBitFlags
{
T mValue;
public:
void SetFlag(int flag) { mValue |= flag;
浏览 1提问于2020-09-11得票数 0
我查看了N4140中类似的内容，但找不到它：
std::ostream& operator<<(std::ostream& os, const T& obj)
{
// write obj to stream
return os;
}
这难道不应该记录在标准里吗？
浏览 4提问于2015-02-06得票数 1
回答已采纳
我正在尝试理解ostream重载。考虑一下这个
#include <iostream>
using std::ostream;
enum class A{a1, a2, a3};
template <class T>
ostream& operator<<(ostream& out, const T& a)
{
switch(a)
{
case T::a1 :
return out<<"a1";
case T::a2 :
return out<
浏览 0提问于2013-06-19得票数 5
回答已采纳
我想在两个&之间定义一个std::vector<int>操作符。这个运算符应该将两个向量的每个元素按位组合在一起，并返回结果向量的非零分量数。
但是，如果我定义了int operator&(const std::vector<int> &lhs, const std::vector<int> &rhs)，编译器就不喜欢它，并要求operator&返回一个布尔值。这实际上是对operator&的限制吗？
浏览 1提问于2020-09-16得票数 0
回答已采纳
1回答
我想知道…是否被认为是C++11中的运算符。如果是这样，它的优先级是什么？
例如，考虑这个非常糟糕的例子，并假设...是一个运算符。
template<typename T, typename...Args>
void foo(T _elm, Args... _args)
{
bar(something,_args...);
}
我怎么知道bar是在第一个参数是something和args...扩展的情况下运行，还是在operator,(something, _args...)的结果上运行？(额外的问题:运算符可以用可变模板重载吗?)
浏览 2提问于2012-03-11得票数 5
回答已采纳
我创建了z3::expr和int对的std::map，并希望存储不同的表达式。但是，当我存储不同类型的表达式(比如首先是64位向量，然后是32位向量)时，编译器为bvslt抛出了一个z3:exception和无效函数应用程序，在第2位置对参数进行了排序不匹配(_ BitVec 64)，但给出了(_ BitVec 32)。如果我只存64个比特，或者只存32个比特，它不会抱怨。我不知道这个bvslt是如何存储两个独立表达式的。
所以我的问题是，有什么方法可以把不同种类的费用存储在地图上吗？
浏览 2提问于2015-05-20得票数 1
回答已采纳
#include <iostream>
struct Int {
int i;
operator int() const noexcept {return i;}
};
int main() {
Int i;
i.i = 1;
std::cout << i;
}
然而，
#include <iostream>
#include <string>
struct String {
std::string s;
operator std::string() const {return s;
浏览 0提问于2013-07-09得票数 6
回答已采纳
我想在模板类中重载">>“操作符，但是当我试图将某些东西写入向量时，我会得到一些错误。这是我的向量函数的一部分：
#include <iostream>
template<typename T>
class Vector
{
public:
T operator[](const int& i);
template <T> friend
std::ostream& operator<<(std::ostream& out, const Vector &v);
templat
浏览 0提问于2014-01-18得票数 0
回答已采纳
简化代码如下：
#include <string>
#include <string_view>
struct object{
operator std::string(){return "";}
}
struct foo{
foo operator[](std::string_view s){
return foo{};
}
template <typename T>
operator T(){
return object{};
}
};
int main(){
foo f;
st
浏览 7提问于2022-09-21得票数 3
回答已采纳
2回答
我正在用C++编写一个内存管理器--也就是说，一个类从堆中分配大量字节，然后为我的程序分配和释放函数。
void* allocate(int size);
void deallocate(void*, int size);
这很好，但我不喜欢的是，我需要这样做才能使用它：
CClass* myobject = (CClass*) manager->allocate(sizeof(CClass));
所以我的问题是，是否有一种方法将类类型传递给函数，而不是使用空指针？这将消除对强制转换的需要和调用的大小，还可能消除将对象大小传递给remove函数的需要。
有谁知道我有更好的方法吗？
浏览 4提问于2013-12-13得票数 0
回答已采纳
6回答
同样的问题也适用于|和|。
&和&&运算符的用途是什么？我能想到的唯一用途是
使用&对int基类型(但不是浮点数/小数)执行逐位Ands操作
返回bool的bools/函数的逻辑短路。通常使用&&运算符。
我想不出其他我用过它的案例了。
有没有人知道其他用途？
-编辑-为了澄清，我问的是任何语言。我见过DateTime使用'-‘返回timespan，字符串使用'+’创建新字符串，等等。我不记得有任何自定义数据类型使用&&和&。所以我在问他们(合理地)可以被用来做什么？我不知道有什么例子。
浏览 1提问于2011-03-06得票数 0
回答已采纳
3回答
我们知道&用于引用和返回变量地址的运算符。我想要做的是将运算符语法更改为_或\(您明白了)。我怎么能这么做？
默认情况：
int *p;
int a;
p = &a;
我想做的是：
int *p;
int a;
p = _a; // or |a
浏览 1提问于2018-07-18得票数 0
回答已采纳
1回答
我是C++的新手，我正在尝试使用模板，但我遇到了问题。我尝试做的是:尝试使用模板计算一个数字的平方，这个数字可以是基本的数据类型，如int，float，以及复数。我还使用模板实现了一个复杂的类，代码如下：
template <typename T>
class Complex {
public:
T real_;
T img_;
Complex(T real, T img) : real_(real), img_(img) { }
};
template <typename T>
T square(T num) {
return num * num
浏览 0提问于2011-07-12得票数 4
回答已采纳
今天，我在stl_pair.h中看到了以下代码：
#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
template <class _T1, class _T2>
inline bool operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
return !(__x == __y);
}
template <class _T1, class _T2>
inline bool operator>(const
浏览 0提问于2014-01-08得票数 5
我想知道为什么basic_ostream的char部分专门化存在以下char重载：
template< class Traits >
basic_ostream<char,Traits>& operator<<( basic_ostream<char,Traits>& os,
char ch );
template< class Traits >
basic_ostream<char,Traits>& operator&
浏览 3提问于2013-02-19得票数 2
2回答
我想要创建一个函数，您可以使用int或string变量作为参数，但我不知道如何使用。
我正在写一个关于我想要达到的目标的小例子：
#include <iostream>
#include <string>
using namespace std;
int function((int a) || (string a))
{
...;
}
int main()
{
int intvar;
string stringvar;
function(intvar);
function(stringvar);
return 0;
浏览 2提问于2016-12-22得票数 1
回答已采纳
4回答
在我从C++学到的所有东西中(其实不是很多)，操作符重载似乎是最难的。总而言之，什么时候最好写一个操作符重载作为友元函数？什么时候必须明确使用*this？使用临时对象总是不好吗？
浏览 1提问于2009-04-22得票数 2
回答已采纳
1回答
我有一个模板函数，它没有参数。
template<typename T>
T cast() {
return T();
}
我想把它专门用于一些模板类，比如向量
template<typename T>
template<>
vector<T> cast<vector<T>>() {
// something special
return vector<T>()
}
因为它不需要任何参数，所以不能过载。我应该做些什么来实现它呢？
浏览 10提问于2022-07-05得票数 0
2回答
#include <iostream>
using namespace std;
template<typename T>
void fun(T t)
{
cout << "match T" << endl;
}
template<>
void fun(int const& t)
{
cout <<"match int const & "<<endl;
}
int main(int argc, char* argv[])
{
con
浏览 1提问于2015-01-16得票数 1
2回答
我想用模板实现一个优先级队列，我试过了，但是我遇到了一些错误，我想通过自定义谓词支持更少的函数。
#include <iostream>
using namespace std;
template <typename T, std::size_t N, typename lessFunction>
class MyClass
{
typedef std::size_t size_type;
public:
void push( const T& t) {
//
size_type index ;//(s
浏览 2提问于2015-06-10得票数 0
回答已采纳
在页面上有一个关于可能实现的部分。它有一段代码：
template <class Base, class T, class Derived>
inline auto INVOKE(T Base::*&& pmd, Derived&& ref) ->
decltype(forward<Derived>(ref).*forward<T Base::*>(pmd)) {
return forward<Derived>(ref).*forward<T Base::*>(pmd);
}
浏览 2提问于2014-12-07得票数 2
回答已采纳
2回答
我试图修改Add函数以表示操作符重载。
#include <iostream>
using namespace std;
template <class T>
class cpair
{
public:
cpair(T x = 0, T y = 0) { A = x; B = y; }
void print()
{
cout << A << " " << B << endl;
}
T A, B;
};
template <class T>
浏览 0提问于2018-09-06得票数 1
回答已采纳
我正在尝试学习boost::bind，boost::lambda库，以及如何将它们与STL算法一起使用。假设我有按int key排序的int-string对的向量。然后，在保持向量排序的同时插入新对的位置可以如下所示：
std::vector<std::pair<int, string> > entries;
...
int k = ...;
// Let's ignore std::lower_bound return value for now
std::lower_bound (entries.begin(), entries.end(), k,
浏览 0提问于2009-11-25得票数 2
回答已采纳
2回答
请考虑以下代码。我正在尝试将向量的向量输出到ostream。
#include <iterator>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
template<typename T>
std::ostream &operator <<(std::ostream &os, const std::vector<T> &v) {
using namespace
浏览 0提问于2012-05-08得票数 4
回答已采纳
1回答
我发现显式返回类型和自动跟踪返回类型之间有一个奇怪的区别。
在下面的代码中，我们在一个整数和一个iter函数上定义了一个结构模板，它使用一个这种类型的对象作为参数。返回类型取决于模板值递减后调用自身的结果。
为了打破实例化循环(至少我是这么想的)，我提供了一个专门化，它返回一个非依赖类型。
我们有一个toy来实例化模板。
下面是一些代码：
template<int i> struct Int {};
constexpr auto iter(Int<0>) -> Int<0>;
template<int i> constexpr auto
浏览 4提问于2014-06-04得票数 24
回答已采纳
5回答
我正在学习C++，并且了解到int类型只是预制的类。所以我想也许我应该试着创造一个。
我想要做的基本上是一个普通的int类
int x;
x=7;
cout << x;
//屏幕输出为7。
所以同样的..。
abc x;
x=7;
cout << x;
我该放什么？
class abc{
\\ HERE!!!!!!
};
所以我可以这样做
class SomeClass {
public:
int x;
SomeClass(int x) {
this->x = x;
}
};
int main(int argc, ch
浏览 0提问于2012-09-27得票数 3
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
