如何为相互依赖的记录定义隐式转换运算符？
在C++中，隐式转换运算符允许在不需要显式类型转换的情况下将一个类型转换为另一个类型。为了为相互依赖的记录定义隐式转换运算符，我们可以使用类型转换运算符。以下是一个示例：
#include<iostream>
class RecordA {
public:
int value;
RecordA(int v) : value(v) {}
// 定义隐式转换运算符为 RecordB
operator RecordB() {
return RecordB(value * 2);
}
};
class RecordB {
public:
int value;
RecordB(int v) : value(v) {}
// 定义隐式转换运算符为 RecordA
operator RecordA() {
return RecordA(value / 2);
}
};
int main() {
RecordA a(10);
RecordB b = a; // 使用隐式转换运算符将 RecordA 转换为 RecordB
RecordA c = b; // 使用隐式转换运算符将 RecordB 转换为 RecordA
std::cout << "a.value: " << a.value<< std::endl;
std::cout << "b.value: " << b.value<< std::endl;
std::cout << "c.value: " << c.value<< std::endl;
return 0;
}在这个示例中，我们定义了两个相互依赖的记录类型：RecordA和RecordB。我们为这两个类型分别定义了隐式转换运算符，以便在不需要显式类型转换的情况下在它们之间进行转换。
在main函数中，我们创建了一个RecordA对象a，并将其隐式转换为RecordB对象b。然后我们将b隐式转换回RecordA对象c。最后，我们输出这三个对象的值，以验证转换是否成功。
这个示例展示了如何为相互依赖的记录类型定义隐式转换运算符，以便在不需要显式类型转换的情况下在它们之间进行转换。
相关·内容
1回答
c#如何为没有重载运算符的类定义+、-、* /运算符？我已经实现了下面的类。在没有重载任何操作符的情况下，上述操作符都能工作，而且它们的工作方式与我将要实现的一样！下面是代码：
class Number
{
private float mDecimal;
public float Decimal
{
get { return mDecimal; }
}
private int mOrder;
public int Order
{
get { return mOrder; }
}
publ
浏览 1提问于2016-12-11得票数 3
回答已采纳
我想了解为什么带有隐式转换的C#记录会生成一个意想不到的Linq表达式。
下面的链接演示了当记录具有与Class或Struct相同的隐式转换实现时，如何为记录生成不同的Linq表达式。
这是在开发与实体框架一起使用的自定义类型时发现的。实体框架抛出一个错误，说明使用记录实现自定义类型时不支持表达式。当使用Class或Struct时，表达式的行为与预期相同。
这使我们发现，根本问题似乎是生成的.NET表达式与记录实现不同。
使用记录或记录结构的表达式(意外)：
System.Collections.Generic.List`1[TestObject].Where(x => (Conver
浏览 13提问于2022-09-26得票数 4
回答已采纳
为什么不能在同一类中共存同一类型的两个运算符(显式和隐式)？假设我有以下内容：
public class Fahrenheit
{
public float Degrees { get; set; }
public Fahrenheit(float degrees)
{
Degrees = degrees;
}
public static explicit operator Celsius(Fahrenheit f)
{
return new Celsius(ToCelsius(f.Degrees));
浏览 5提问于2012-06-05得票数 5
回答已采纳
1回答
编写隐式和显式类型转换操作符非常简单。
我可以找到很多关于如何编写它们的文档，但是很少有关于when的文档，或者关于为什么要编写它们的文档。
我已经对现有的实现做了一些调查；例如，.NET的引用源中的：
public struct BigInteger : IFormattable, IComparable, IComparable<BigInteger>, IEquatable<BigInteger>
{
public static implicit operator BigInteger(Byte value)
{
return ne
浏览 10提问于2022-08-16得票数 2
回答已采纳
2回答
在C++11中，建议：
显式地定义我们自己的复制/移动构造函数，这样编译器就不会自己做(根据)。
显式声明一个参数构造函数为显式，以避免隐式转换(根据)。
在这个思路中，应该声明转换操作符explicit，以防止编译器使用它们来执行隐式转换吗？
浏览 1提问于2015-12-23得票数 1
回答已采纳
XNamespace aw = ""；
这怎么可能？通常，要创建特定类的实例，我们需要使用New关键字或返回创建实例的特定静态方法。
有一个具体的实现允许这是可能的吗？谢谢。
浏览 0提问于2018-03-21得票数 0
回答已采纳
在有效C++第三版的第15项中，RAII类字体包含作为其资源的FontHandle。该项目显示了Font类如何为其FontHandle提供隐式转换函数，如下所示：
operator FontHandle() const
{return f;}
此代码与以下代码有何不同：
FontHandle operator()() const
{return f;}
如果没有区别，它是不是一种不常见且不常用的语法？
浏览 0提问于2011-01-19得票数 2
回答已采纳
1回答
我有以下代码
class A {
private:
int n;
public:
A(int n) : n{n} {}
A(const A & a) : n{a.n} {}
};
class B {
private:
int m;
public:
B(int n) : m{n} {}
operator A() const { return A(m); }
ope
浏览 3提问于2014-10-07得票数 4
回答已采纳
1回答
嵌套隐式算子
、、
我有一个名为Optional< T >的自定义类。该类重写隐式运算符，如下所示：
public static implicit operator Optional<T>(T value)
{
return new Optional<T>(value);
}
public static implicit operator T(Optional<T> value)
{
return value.value;
}
好的，到现在为止，像这样的直接操作是这样的：
Optional<int> val = 33; //ok
int
浏览 1提问于2016-10-05得票数 3
回答已采纳
3回答
我试图理解为什么我的c++编译器与以下代码混为一谈：
struct Enum
{
enum Type
{
T1,
T2
};
Enum( Type t ):t_(t){}
operator Type () const { return t_; }
private:
Type t_;
// prevent automatic conversion for any other built-in types such as bool, int, etc
template<typename T> operator T () const;
浏览 3提问于2015-12-09得票数 5
回答已采纳
1回答
这是我的代码：
#include <iostream>
using namespace std;
class Sales{
public:
Sales(int i = 0):i(i){}
explicit operator int(){ return i; }
private:
int i;
};
int main(){
Sales s(5);
if(s == 4) cout << "s == 4" << endl;
else cout << "s != 4" <
浏览 1提问于2017-11-23得票数 2
回答已采纳
1回答
假设我有以下代码：
class Base
{
};
class Foo
{
public:
Foo(Base* base)
{
}
};
class BarBase
{
public:
operator Base*()
{
return base;
}
private:
Base* base;
};
class Bar : public BarBase
{
public:
Bar()
{
Foo* foo = new Foo(this);
}
};
代码无法编译，GCC 6.
浏览 1提问于2017-04-21得票数 0
回答已采纳
为什么可以显式地从double转换到Foo，即使Foo只定义了从int到Foo的显式转换
为什么在我的例子中double隐式转换为int
using System;
class Program
{
static void Main(string[] args)
{
double doub = 15.7;
Foo foo = (Foo)doub;
Console.WriteLine(foo.value); //writes "15"
}
}
struct Foo
{
public int valu
浏览 0提问于2016-02-29得票数 5
1回答
考虑以下方案：
#include <iostream>
using namespace std;
class Foo {
public:
int k;
operator int() {
cout << "convert int" << endl;
return k;
}
#if USE_COMPARE
bool operator < (int rhs) {
cout << "compare with" << e
浏览 1提问于2015-02-05得票数 5
回答已采纳
1回答
我正在使用一种结构，这种结构需要针对字符串的隐式运算符，并且遇到了一个我从未考虑过的基本问题。
public static implicit operator Version (string value) {...}
我可以理解，只有显式操作符才能强制转换，但如果隐式运算符已经重载，则无法考虑需要它的情况。有一个吗？
浏览 0提问于2013-09-04得票数 3
回答已采纳
2回答
给定代码：
public class Filter<T>
{
private bool selected = false;
public bool Selected { get { return selected; } }
private T value;
public T Value { get{ return this.value; } set { this.value = value; selected = true; }
}
public class Test
{
public void filter()
{
浏览 3提问于2013-04-05得票数 1
回答已采纳
我有一个结构：
public struct Decibel
{
public readonly double Value;
public Decibel (double value)
{
Value = value;
}
public static implicit operator Decibel (double decibels)
{
return new Decibel (decibels);
}
public static implicit operator double (Decib
浏览 2提问于2015-04-29得票数 8
回答已采纳
1回答
请考虑以下代码。
#include <functional>
int main(void)
{
std::function<void()> f1;
if (f1) { /* ok */
...
}
bool b = f1; /* compile-error */
bool B = !f1; /* ok */
...
}
在某些情况下，std::function<>隐式转换为bool，但并不是在所有情况下都这样。将其分配给bool-variable不起作用，而操作或在if()-statemen
浏览 2提问于2016-09-20得票数 3
回答已采纳
3回答
好吧，我已经找了一段时间了。我构建了一个小类来查看类型安全枚举对于字符串的实现有多难，因为我想将它们用于数据库字段名等。我从来不喜欢枚举只能用于整数这一事实。
然而，即使我已经为这个类实现了一个implicit operator，每次我尝试使用它时，它都会给我一个无效的强制转换异常。我不知所措，因为在这一点上我看不到我的代码有任何问题。
下面是这个类：
/// <summary>
/// SBool - type-safe-enum for boolean strings
/// </summary>
public sealed class SBool
{
p
浏览 2提问于2013-04-02得票数 10
回答已采纳
我有以下类定义：
struct MyClass {
int id;
operator MyClass* () { return this; }
};
我对上面代码中operator MyClass* ()行的作用感到困惑。有什么想法吗？
浏览 0提问于2017-11-05得票数 4
为什么iWantInt(a)不编译，而iWantInt(b) --更令人惊讶的是-- iWantInt会编译？
我如何理解这种行为？
既然我可以隐式传递a，为什么不能显式地将它传递给iWantInt呢？
iWantA和iWantInt有什么不同？为什么它的工作方式不一样？
这种行为在什么地方有记录或解释吗？
如果Scala接受iWantInt(a)，会导致什么样的问题？为什么是禁止的？
class A
class B
object Run extends App {
implicit val a = new A
implicit val b = new B
implicit d
浏览 3提问于2014-03-31得票数 4
回答已采纳
在C#中是否可以为IBAN、BIC (可能使用struct)创建一个非常简单的值类型？这自动工作的功能，如Json序列化和EF核心保存？
我希望在转换为Json的数据对象以及通过EF存储的实体中使用原语类型
public class AccountTransaction
{
public Iban RecipientIban { get; set; }
public Bic RecipientBic { get; set; }
}
例如，对于EF，我不想每次使用这些类型时都指定一些值转换器。或者，我不想每次在对象中使用这些类型时都指定一些自定义JsonSerializer。它们
浏览 1提问于2019-10-23得票数 5
回答已采纳
我使用g++并编写了一个简单的函数：
#include <memory>
std::shared_ptr<char> ptr;
bool fails_compiling()
{
return ptr;
}
从接口中可以看到，shared_ptr实现包括一个bool操作符，甚至可以应用如下所示的快速修复：
return static_cast<bool>(ptr);
现在它会编译。
为什么返回算法不像if()和while()那样尝试自动转换为if()？
浏览 6提问于2016-09-19得票数 9
回答已采纳
当我们有两个结构，其中一个是隐式可转换的，那么这两个结构的System.Nullable<>版本似乎也是隐式可转换的。类似地，如果struct A有一个隐式转换为struct B，那么A?也会转换为B?。
下面是一个示例：
struct MyNumber
{
public readonly int Inner;
public MyNumber(int i)
{
Inner = i;
}
public static implicit operator int(MyNumber n)
{
return n.Inner;
}
}
在某些方法
浏览 3提问于2012-05-09得票数 6
回答已采纳
1回答
重载显式强制转换运算符
、、、、
我有一段代码：
public class Leg : ProxiestChild
{
public virtual Name { get; set; }
}
问题是：
var leg = new Leg(); // leg is not Leg, instead ProxiedLeg
var trueleg = (Leg)leg; // exception leg is a ProxiedLeg
我需要这样的东西
public class ProxiestChild
{
// some method that overloads explicit CAST
// wh
浏览 0提问于2012-01-10得票数 9
回答已采纳
1回答
我基本上希望string/FormattableString有两个单独的重载(背景是，我希望促使人们使用字符串常量来处理日志消息，并通过结构化日志记录传递参数，而不是通过日志消息来简化分析。因此，FormattableString日志记录方法将被淘汰)。
现在，由于编译器的工作方式，您不能直接重载方法，因为在传递字符串之前，FormattableString会转移到字符串中。但是，有一个定义隐式重载的包装器结构是可行的：
public struct StringIfNotFormattableStringAdapter
{
public string StringValue { get
浏览 2提问于2020-03-20得票数 6
回答已采纳
固定:参见底部的注释
我正在实现一个泛型类，它支持两个特性:隐式类型转换和自定义相等运算符。好吧，它也支持平等，如果是这样的话。
1) if ( "value" = myInstance ) then ...
2) Dim s As String = myInstance
3) Dim s As String = CType(myInstance,String)
我遇到的问题是，如果我支持#2，隐式转换，那么我就无法让我的等式操作符工作，因为他们抱怨没有转换是最具体的。
我得到的错误是：(为了简洁起见，简化一点)：
Overload resolution failed beca
浏览 3提问于2008-09-30得票数 3
回答已采纳
考虑以下代码：
class Program
{
public static explicit operator long(Program x) { return 47; }
static int Main(string[] args)
{
var x = new Program();
Console.WriteLine((decimal) x);
}
}
令我惊讶的是，这会输出47；换句话说，即使强制转换为decimal，也会调用explicit operator long。
C#规范中有没有明确说明应该发生这种情况(如果是，具
浏览 0提问于2011-11-02得票数 16
回答已采纳
假设我有以下scala代码：
case class Term(c:Char) {
def unary_+ = Plus(this)
}
case class Plus(t:Term)
object Term {
implicit def fromChar(c:Char) = Term(c)
}
现在，我从scala控制台获得以下内容：
scala> val p = +'a'
p: Int = 97
scala> val q:Plus = +'a'
<console>:16: error: type mismatch;
f
浏览 0提问于2013-02-28得票数 0
回答已采纳
当我实现从int到类型的cast运算符时，它似乎也“自动”支持从浮点进行转换。我不想我的类型是含蓄的-从浮子铸造！我不希望它是显式的-从浮(从浮子定义显式转换是不够好的)。
我能阻止这种行为吗？有说明说明吗？
原因:我正在尝试学习/探索确定性的定点数学，而浮点的转换通常是“危险区域”。Int转换很好，需要隐式的。在需要浮点转换的情况下，我更喜欢静态方法来更好地指定意图，例如：MyNumber.ParseUnsafe(0.1f)。
public struct MyNumber
{
public int raw;
public static implicit operator M
浏览 2提问于2021-12-18得票数 0
在C#中，运算符将根据结果的大小隐式地缩小和扩大结果变量。
UInt32 exampleA = 10000000/2; // Will return a UInt32
UInt32 exampleB = 1000000000000/2; // Will implicitly widen to UInt64 and cause a compile error
UInt64 exampleC = 1000000000000/2; // Will implicitly widen to UInt64 without error
你能为一种方法做这件事吗?如果是的话，怎么做？我认为它
浏览 2提问于2015-12-15得票数 1
回答已采纳
我已经阅读了有关转换运算符的文章，但是我仍然不确定何时调用转换运算符。请考虑以下示例：
class foo
{
public:
operator char*()
{
return "SomeText";
}
};
foo d;
const char* m = static_cast<char*>(d);
为什么这个转换运算符会被调用？是哪个接线员打来的？
浏览 3提问于2014-09-24得票数 1
回答已采纳
2回答
有问题的代码：
struct PCArea {
PCArea(
int minxx = 0,
int minyy = 0,
int maxxx = 0,
int maxyy = 0
) {}
};
struct NDCVolume {
NDCVolume() {}
operator PCArea() const;
};
// how does this operator work? how to use/read it?
NDCVo
浏览 2提问于2012-07-20得票数 1
回答已采纳
我正在为它编写类似STL的向量和迭代器类。而今天，虽然写擦除功能，采取const_iterator，原来没有对话从迭代器到const_iterator.I试图找到一些信息，但我仍然不知道如何做。但STL矢量使它成为了某种形式。我的爱尔兰人课：
template<typename VectorDataType>
class Iterator{
public:
using value_type = VectorDataType;
using difference_type = int;
using poin
浏览 3提问于2020-06-18得票数 0
回答已采纳
为什么我不能像这样同时定义隐式和显式运算符？
public class C
{
public static implicit operator string(C c)
{
return "implicit";
}
public static explicit operator string(C c)
{
return "explicit";
}
}
不过，您可以执行此操作:)
class
浏览 0提问于2009-04-17得票数 33
2回答
我已经将模型中的字符串属性转换为一个类，该类包含自定义类型EngNum之间的隐式运算符。我这样做是为了让这种类型的所有出现都有我的自定义编辑器，即使该类型应该像字符串一样运行和使用。
我的问题是，该属性不再正确地绑定到我的模型中，即使值在POST的形式中也是如此。
有关我的EngNum类型，请参见下面的内容：
public class EngNum
{
private string internalString;
public EngNum() { }
public EngNum(string number)
{
internalString
浏览 1提问于2012-08-23得票数 0
回答已采纳
//Main method
Belle jhbh = new();
IOpera kujb = (IOpera)jhbh;
interface IOpera {
}
interface IFire:IOpera {
}
class Belle :fff,IFire {
}
你能告诉我，这个演员是怎么工作的吗？
对我来说，以下两个变体会做同样的事情：
IOpera kujb = (IOpera)jhbh；
IOpera kujb = jhbh；
我的意思是，最终是kujb决定了哪些成员是可访问的，哪些是不可访问的，对吧。
既然在这两种情况下，kujb都指向同一个对
浏览 1提问于2022-07-31得票数 0
回答已采纳
为什么Visual Studio 2010和Visual Studio 2012无法编译此代码？
Codepad.org、Xcode、gcc、LLVM、Clang都没有问题，但Visual Studio把床给拉了：
struct S {
template <class T> inline operator T () const { return T (); }
};
int main () {
// NOTE: "S()" denotes construction in these examples
struct F {
void operato
浏览 1提问于2012-11-18得票数 12
2回答
我正在实现一个表示分数的c++类。这是我的代码。
class Fraction
{
public:
Fraction(char i);
Fraction(int i);
Fraction(short i);
Fraction(long int l);
#ifdef __LP64__
Fraction(long long l);
#endif
Fraction(float f);
Fraction(double d);
Fraction(double x, do
浏览 0提问于2011-06-02得票数 4
回答已采纳
我有以下功能：
uint_fast32_t write(const std::vector<std::byte>& bytes_to_write) const
{
...
}
我想用可变数量的std::byte来调用它：
std::byte low_byte { 0 };
std::byte hi_byte{ GPIO_PINS::GPIOH0 | GPIO_PINS::GPIOH3 };
write({
INST::SET_LOW,
low_byte,
0xFB,
INST::SET_HI,
hi_byte,
0x
浏览 0提问于2019-04-15得票数 2
2回答
当我在MonoDevelop中编译我的C#项目时，我得到以下错误：
Type of conditional expression cannot be determined as 'byte' and 'int' convert implicitly to each other
代码片段：
byte oldType = type;
type = bindings[type];
//Ignores updating blocks that are the same and send block only to the player
if (b == (byte)((
浏览 0提问于2011-04-03得票数 24
回答已采纳
2回答
我有一个XmlRpcValue对象，想要从这个对象中获取值。该类提供了一些接口来获取这些值。但我不确定如何使用它们。该接口在此最小文档()中定义。我尝试调用重载函数()，但我不确定调用此函数的正确语法。
简化代码如下：
XmlRpc::XmlRpcValue p;
cout<<p["some_value"]<<endl;
int val = p["some_value"]();
编译错误出现在上面的第3行。cout语句打印正确的值。我尝试了重载操作符()的几种排列，但每种排列都只会导致不同的编译错误。我应该如何从这个对象中获取值？
浏览 56提问于2013-07-16得票数 1
回答已采纳
我已经将这个问题提炼成我能想到的最简单的代码样本。为什么不从泛型方法调用显式运算符？
class Program
{
static void Main(string[] args)
{
A a = new A();
B b = (B)a; // works as expected
b = Cast<B>(a);
}
static TResult Cast<TResult>(object o)
{
return (TResult)o; // throws Invali
浏览 0提问于2013-01-10得票数 5
回答已采纳
3回答
给定此示例，其中包含几个重载：
#include <iostream>
class T
{
public:
operator const wchar_t *(void) const
{
std::cout << "Conversion" << std::endl;
return L"Testing";
}
};
template <class Elem>
class A
{
};
template <class T>
v
浏览 4提问于2012-02-09得票数 3
回答已采纳
我以前也问过一个类似的问题()。
现在一个新的错误把我弄糊涂了。
cout << ++a1 << endl;将调用函数operator double()。
如果在代码Fraction& operator++()中删除&以使其成为Fraction operator++()，它将调用ostream& operator<<(ostream& os, Fraction&& obj)。
#include <iostream>
using namespace std;
class Fraction
{
pri
浏览 1提问于2019-05-14得票数 1
回答已采纳
考虑这个简单的例子：
template <class Type>
class smartref {
public:
smartref() : data(new Type) { }
operator Type&(){ return *data; }
private:
Type* data;
};
class person {
public:
void think() { std::cout << "I am thinking"; }
};
int main() {
smartref<person&g
浏览 0提问于2009-08-20得票数 46
回答已采纳
class NullClass{
public:
template<class T>
operator T*() const {return 0;}
};
当时我正在阅读有效的C++，我偶然遇到了这个类，我实现了这个类并进行了编译。我对此有几点怀疑：
它没有返回类型。
这个接线员是什么。
以及它的实际作用。
浏览 1提问于2014-07-31得票数 13
回答已采纳
完整的实现在这里，我使用带有隐式类型转换的结构来隐式地来回转换源类型，并通过结构的泛型参数来描述检查规则。在我看来，它可以减少代码重复，并且可以作为dsl读取。
使用方法：
static void Main(string[] args)
{
string s = Size(null);//result: argument exception
Console.WriteLine(Lenght(null));//result 0
DivByZero(0);// result: argument exception
Lo
浏览 0提问于2011-10-23得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
