我很想知道为什么我们需要为小数类型追加m或M?
我认为编译器有足够的信息,因为我们声明Decimal关键字.
可以请一些人解释为什么编译器不能确定该值应该被视为十进制而不是双精度.
在以下示例中,应调用哪个转换函数?为什么要选择那个呢?
struct A
{
operator int();
operator int*();
};
A x;
int i = x + 1;
Run Code Online (Sandbox Code Playgroud)
编译器选择operator int()..但为什么?
以下是来自C++ 03的一些相关引用:
来自[expr.add]
另外,两个操作数都应具有算术或枚举类型,或者一个操作数应是指向完全定义的对象类型的指针,另一个操作数应具有整数或枚举类型.
来自[转]
具有给定类型的表达式将在多个上下文中隐式转换为其他类型:
- 用作运算符的操作数时.运营商对其操作数的要求决定了目的地类型
c++ overloading type-conversion language-lawyer implicit-conversion
我正在尝试使用specs2,我有隐式转换的问题,这些转换与我从scala.concurrent.duration._中导入的转换混合,是否有任何方法可以从范围中排除隐含的转换?
import org.specs2.mutable.Specification
import scala.concurrent.duration._
class StatisticsSampleCacheSpec extends Specification {
val map: Map[Long, Duration] = Map(
1L -> 5.minute,
3L -> 3.day,
5L -> 5.day,
7L -> 30.day)
}
Run Code Online (Sandbox Code Playgroud) 鉴于此代码:
#include <iostream>
template<typename... Args> class X;
template<typename T>
class X<T> {
public:
T value;
X(T value_) : value(value_) {}
};
template<typename T, typename... Args>
class X<T, Args...> : public X<Args...> {
public:
T value;
X(T value_, Args... args) : value(value_), X<Args...>(args...) {}
};
template<typename T>
std::ostream& operator <<(std::ostream& stream, const X<T>& value_) {
stream << value_.value;
return stream;
}
template<typename T, typename... Args>
std::ostream& operator <<(std::ostream& stream, const X<T, Args...>& value_) {
stream << value_.value << " " << …Run Code Online (Sandbox Code Playgroud) 因此,给出以下代码:
int main(void) {
int i;
i = 12.1234;
i++;
return 0;
}
Run Code Online (Sandbox Code Playgroud)
我编译了代码,我期望并希望编译器给我一个警告,但事实并非如此.我的编译器配置错了吗?有没有办法让我的编译器发出警告?
这是我用的
cc -Wall test.c
请考虑以下示例:
struct ConvertibleStruct {};
enum class ConvertibleEC {};
struct Target {
// Implicit conversion constructors
Target(ConvertibleStruct) {}
Target(ConvertibleEC) {}
};
Target operator~(const Target& t) {
return t;
}
Target anotherFunction(const Target& t) {
return t;
}
int main() {
ConvertibleStruct t;
ConvertibleEC ec;
~t; // 1. Works finding the operator overloaded above
~ec; // 2. Fails to compile on clang 3.4 and gcc 4.8.2
operator~(ec); // 3. Works finding the operator overloaded above
anotherFunction(ec); // 4. Works
}
Run Code Online (Sandbox Code Playgroud)
编译器版本:
以上调查结果适用于 …
c++ operator-overloading implicit-conversion c++11 enum-class
我正在阅读http://www.cplusplus.com/doc/tutorial/typecasting/.它说:
否则,如果转换是在相同类型的数字类型之间(整数到整数或浮动到浮动),则转换有效,但该值是特定于实现的(并且可能不是可移植的).
但我真的不明白上面引用的意思是什么?有人请用一个简单的例子解释一下吗?为什么在相同类型的数字类型之间进行转换会导致特定于实现的值?是什么原因?
我发现一些线程严重意味着无法完成,但没有一个使用完全相同的运算符和条件组合,所以我想更具体地问.希望这意味着对某人来说这是一个快速而简单的答案......无论如何!
考虑一个示例代理类,用于管理较大存储块中的值 - 如此过于简化但有代表性的示例:
class SomeProxyThing {
std::uint32_t storage;
public:
operator std::uint16_t() const
{
return storage & 0x0000FFFF;
}
SomeProxyThing &operator=(std::uint16_t const value)
{
storage &= 0xFFFF0000;
storage |= value;
}
};
Run Code Online (Sandbox Code Playgroud)
我想通过用户定义的s 来完成所有作业operator.在这种情况下,用户应该只能传入或取出"暴露"类型std::uint16_t.我可能正在使用各种代理类类型,并希望它适用于所有这些类型.理想情况下,对于任何类型的组合,我只需键入someProxy = anotherProxy并让编译器完成其余的工作.
但是,当赋值的左侧和右侧具有相同或继承相关的类型时,默认的复制赋值运算符 - 当然 - 与此目标冲突.它复制了整个storage,从而破坏了另一半uint32_t- 而不是根据需要只复制'暴露'值.这是正确的!对于大多数情况.但即使LHS和RHS类型相同,我也想要一种"通过转换分配"的方法.为了避免这种情况,我可以:
operators 执行'代理'副本- 这是我一直在做的,但它似乎有点hacky,并且像任何用户定义的构造函数/赋值运算符一样,打破了平凡的可复制状态对的struct-我需要保持.它仍然memcpy()s ^ 反正在g++,但我想定义的行为.= delete复制赋值运算符(我们现在可以为TC类型执行).但是,赋值仍然会尝试使用它并抛出编译错误 - …这是一个基本问题,我希望谷歌很容易,但没有找到答案.
让我们说我有一个枚举:
enum abc { a, b, c };
Run Code Online (Sandbox Code Playgroud)
支持的隐式转换有哪些?编译器之间是否有编译器扩展或不同的行为?
我问的是隐式转换为枚举:
enum abc test = (** which type can appear here? **);
Run Code Online (Sandbox Code Playgroud)
以及枚举的隐式转换:
(** which type can appear here? **) test2 = test;
Run Code Online (Sandbox Code Playgroud)
我想知道C和C++的答案.
我有一个foo包含类的包FStream.package对象foo定义了一些提供扩展器方法的隐式值类FStream.我想将这些值类从包对象中移出并放入它们自己的单独文件中,但我也希望它们在我使用时始终可用FStream(或者最好是当我使用foo包中的任何东西时.是否可以实现这一点?我尝试将隐式值类放入其他对象中,但我无法从对象扩展.尝试将它们放在类或特征中,但隐式值类只能在其他对象中定义.
富/ FStream.scala
package foo
class FStream {
def makeFoo(): Unit = ???
}
Run Code Online (Sandbox Code Playgroud)
富/ package.scala
package foo
package object foo {
// I want to move these definitions into separate files:
implicit class SuperFoo(val stream: FStream) extends AnyVal {
def makeSuperFoo(): Unit = ???
}
implicit class HyperFoo(val stream: FStream) extends AnyVal {
def makeHyperFoo(): Unit = ???
}
}
Run Code Online (Sandbox Code Playgroud)
酒吧/ usage.scala
package bar
import foo._ // …Run Code Online (Sandbox Code Playgroud)