一元+；操作员有什么实际用途吗？ 是一元代码> +>代码>操作符，只包含与一元 ->代码>运算符的对称性，或者在C++代码中找到一些实用的用法？p>

在这里搜索时，我遇到了，但唯一有用的场景是预处理器宏。知道这些很好，但它们似乎是一些不太常见的情况，并且涉及宏。是否有使用更普通C++代码的用例？

<代码> char ch=“a”；

char ch = 'a';
std::cout << ch << '\n';
std::cout << +ch << '\n';

---

std：：cout与一元

-

对称并非完全无用；它可以用于强调：

const int foo = -1;
const int bar = +1;

---

重载的一元数

+

可以用来表示在执行一些非平凡计算时产生与其操作数相同逻辑值的操作。（我在艾达中看到过这种类型的转换，它允许一元代码>代码> +代码>，但不转换，要重载。我没有一个好的C++例子，可以说它是一个很差的样式。（再说一遍，我看到过很多关于重载的咆哮

如果你明确地避开类的任何数值语义，那么任何运算符重载都是明确的，不能“像int那样做”。在这种情况下，一元加号可能会有任何意义，不仅仅是返回
*这个

突出的例子：对于嵌入式EBNF，它生成一个解析器规则，使其参数（以及解析器规则）匹配一次或多次。
一元+应用整数提升。@PeteBecker的回答显示了一种有用的方法

另一方面，请注意，非作用域枚举类型会升级为整数类型，该类型可以表示
枚举
中的所有值。因此，在C++03中，即使没有C++11的
std:：底层_类型
，也可以执行以下操作：

enum MyBitMask {
    Flag1 = 0x1,
    Flag2 = 0x2,
    Flag3 = 0x4,
    Flag4 = 0x8000000
};

inline MyBitMask operator&(MyBitMask x, MyBitMask y) {
    return static_cast<MyBitMask>( +x & +y );
}

inline MyBitMask operator|(MyBitMask x, MyBitMask y) {
    return static_cast<MyBitMask>( +x | +y );
}

枚举MyBitMask{
Flag1=0x1，
Flag2=0x2，
Flag3=0x4，
Flag4=0x8000000
};
内联MyBitMask运算符&（MyBitMask x，MyBitMask y）{
返回静态投影（+x和+y）；
}
内联MyBitMask运算符|（MyBitMask x，MyBitMask y）{
返回静态|U型（+x |+y）；
}
一元
+
运算符将左值转换为右值：

struct A {
  static const int value = 1;
};

// ...

int x = std::min(0, A::value);

哦，不！这段代码不会链接，因为有人忘记定义（以及声明）
A:：value
std:：min
通过引用获取其参数，因此
A:：value
必须有一个地址，以便引用可以绑定到它（从技术上讲，“一个定义”规则说它必须在程序中精确定义一次）

无所谓，一元加拯救：

int x = std::min(0, +A::value);

一元加号创建一个具有相同值的临时值，引用绑定到临时值，因此我们可以解决缺少的定义

这不是您经常需要的，但它是一元加号运算符的一个实际用法。
有点晚了，但我偶然发现了一个非常扭曲的用法。
+
运算符显然很有用（如果不是严格必要的话）在围绕遇到空预处理器令牌的可能性设计保护措施时。有关更深入的讨论，请参阅

这很实用，但一点也不令人愉快。
因为对于算术变量，运算符+会生成一个新值。
我使用它生成引用类型（代理）的值副本

模板类参考{
T*impl；//或更复杂的实现
公众：
T运算符+（）常量{return*impl；}
运算符T&（&{return*impl}
}

另一种选择是使用
运算符*
，但是

的

ref\u可能会与类似指针的对象混淆。
除此之外，
+
将lambda转换为函数指针。通常转换会自动进行，但有时不会

例如，这不会编译：

std::array arr{
    [](int x){return x*x;},
    [](int x){return x*x*x;},
};

您可以通过将函数指针类型指定为
std:：array
模板参数、或使其工作，您可以执行以下操作：

std::array arr{
    +[](int x){return x*x;},
    +[](int x){return x*x*x;},
};

因为对于算术变量，运算符+生成一个新值，
我通常使用它来生成类似引用（代理）类型的值副本

模板类参考{
T*impl；//或更复杂的实现
公众：
T运算符+（）常量{return*impl；}
运算符T&（&{return*impl}
}
...
r=t的ref_；
自动s=+r；//这将强制复制

另一种选择是使用
运算符*
，但是
的
引用可能会与类似指针的对象相混淆。
数学上？不。但它可能会在类的运算符重载中找到用途。@ValekHalfHeart:是的，但是任何重载都会被视为滥用。@rodrigo，但仍然可以我给这个
提供了一个副作用，不是吗？如果这是好的或有用的DSL设计是另一个问题。@ArneMertz:和Boost一样好。Spirit是，它肯定是一种语言滥用。这并不是说它有任何优点，但操作符重载并不是为了做这类事情而设计的，当你意识到你无法改变时，这一点很明显运算符优先级和您对旧运算符的新奇含义有点松散（
cout@ApproachingDarknessFish:它可能会在类的运算符重载中找到用途。请举例说明。数值是否与ASCII等效？@David-使用ASCII的编译器，是的。对于其他编码（罕见），不。似乎对我不起作用——这些可能是罕见的编码吗？@David-不知道你的程序是怎么回事，但104是“h”的ASCII码。哦，对不起，我看到我的代码中有一个错误，我刚刚修复了。希望这不会让你太困惑。我希望我们能过载
@
，
$
，以及
@MooingDuck，当你在做的时候，我们能不能用
+-*/%=！~^^ |&*[]（）@$
的任何组合来生成我们自己的运算符？大多数这些运算符都会使解析变得模棱两可。如果编译器看到
a+-b
，那是内置的还是用户重载？@MooingDuck如果存在这样的重载，那就是重载；el
std::array arr{
    +[](int x){return x*x;},
    +[](int x){return x*x*x;},
};

template<class T> class ref_of{
   T* impl_; // or a more complicated implementation
public:
   T operator+() const{return *impl_;} 
   operator T&()&{return *impl_;}
}
...
ref_of<T> r = t;
auto s = +r; // this forces a copy