需要帮助铸造操作员...... [英] need help with casting operators...
问题描述
我有两种对象类型ClassA和ClassB
class ClassA {
public：
int data;
运算符ClassB（）
{
ClassB b;
b.data = data + 1;
返回（b）;
}
};
类ClassB {
public：
int data;
运算符ClassA（）
{
ClassB b;
b.data =数据 - 1;
返回（b）;
}
}
所以...如果我说：
ClassA a1，a2;
ClassB b;
a1.data = 5;
b = a1;
a2 = b;
然后a2应与a1相同和b应该是6.
首先我无法编译，因为ClassB在编译时不知道ClassA
.. 。
是否必须在两个类中都有int数据或者A可以继承B
反之亦然？
两个铸造运营商都可以只在课堂上？
我猜这非常类似于：
浮动a1，a2;
int b;
a1 = 5.0
b = a1;
a2 = b;
当然在这种情况下会失去优点..但是铸造
操作工作......
帮助？
TIA
JustSomeGuy写道：我有两种对象类型ClassA和ClassB
< snip>
首先我无法编译，因为ClassB在编译时并不知道ClassA
是否需要在两个类中都有int数据，或者A可以从B继承而反之亦然？
两个类的转换运算符只能存在于类中吗？
< snip>
我修复了一些逻辑错误（ClassB'的运算符ClassA返回了一个
ClassB）：
class ClassB;
class ClassA {
public：
int data;
operator ClassB（）;
};
class ClassB {
public：
int data;
运算符ClassA（）;
};
ClassA ::运算符ClassB（）
{
ClassB b;
b.data =数据+ 1;
返回（b）;
}
ClassB ::运算符ClassA（）
{
ClassA a;
a.data = data - 1;
返回（a）;
}
int main（）
{
ClassA a1，a2;
ClassB b;
a1.data = 5;
std :: cout< < a1.data == << a1.data<< std :: endl;
b = a1;
std :: cout<< b.data == << b.data<< std :: endl;
a2 = b;
std :: cout<< a2.data == << a2.data<< std :: endl;
返回0;
}
- Pete
JustSomeGuy写道：我有两个对象类型ClassA和ClassB
类ClassA {
public：
int data ;
运营商ClassB（）
{
ClassB b;
b.data = data + 1;
return（b）;
}
类公开：
int数据;
运算符ClassA（）
{B> B B; b.data = data - 1;
return（b）;
你可能意味着
ClassA a;
a.data = data - 1;
返回a;
}
}
;
所以......如果我说：
ClassA a1，a2;
ClassB b;
a1.data = 5;
b = a1;
a2 = b;
然后a2应该与a1相同，b应该是6.
首先我不能把它编译好，因为ClassB不是在编译时知道ClassA
...
是的，那就是你需要将类定义和成员分开的地方
函数定义：
struct B;
struct A {
int data;
运算符B（）const ;
};
struct B {
int data;
运算符A（）const;
};
A :: operator B（）const
{
...
}
B ::运算符A（）const
{
...
}
是否必要在两个类中都有int数据，或者A可以从B继承
，反之亦然？
继承？取决于你的模型。
两个演员都可以只存在于类中吗？
No.
我猜这非常类似于：
浮动a1，a2;
int b;
a1 = 5.0
b = a1;
a2 = b;
在这种情况下，当然会失去优点..但铸造
操作工作...
这是因为语言已知转换操作符。
Victor
" JustSomeGuy" <否*** @ ucalgary.ca>在消息中写道
news：40 *************** @ ucalgary.ca ...我有两个对象类型ClassA和ClassB
类ClassA {
公共：
int数据;
运营商ClassB（）
{B> B B;
b.data = data + 1;
返回（b）;
}
};
类ClassB {
public：
int数据;
运营商ClassA（）
{B>阶段b;
b.data =数据 - 1;
返回（b）;
}
}
所以...如果我说：
ClassA a1，a2;
ClassB b;
a1.data = 5;
b = a1;
a2 = b;
然后a2应该与a1相同，b应该是6.
首先关闭我无法编译，因为ClassB在编译时不知道ClassA
是否需要在两个类中都有int数据或者A继承自B
反之亦然？
可以机器人h铸造操作员只存在于类中？
我猜这非常类似于：
浮动a1，a2;
int b;
a1 = 5.0
b = a1;
a2 = b;
当然在这种情况下有一种损失的优点..但是铸造
操作工作......
#include< iostream>
#include< ostream>
B级;
A级
{
int数据;
public：
A（int d = 0）：data（d）{}
operator B（）const;
friend std： ：ostream的&安培; operator<<（std :: ostream& os，const A& a）
{
return os<< a.data;
}
};
B级
{
int data;
public：
B（int d = 0）：data（d）{}
运算符A（）const {return data - 1; }
朋友std :: ostream& operator<<（std :: ostream& os，const B& b）
{
return os<< b.data;
}
};
A :: operator B（）const {return data + 1; }
int main（）
{
A a1（5）;
A a2 ;
B b;
b = a1;
a2 = b;
std :: cout<< a1 == << a1<< ''\ n''
<< a2 == << a2<< ''\ n''
<< b == << b<< ''\ n'';
返回0;
}
输出：
a1 == 5
a2 == 5
b == 6
-Mike
I have two object types ClassA and ClassB
class ClassA {
public:
int data;
operator ClassB()
{
ClassB b;
b.data = data + 1;
return (b);
}
};
class ClassB {
public:
int data;
operator ClassA()
{
ClassB b;
b.data = data - 1;
return(b);
}
}
So... If I say:
ClassA a1, a2;
ClassB b;
a1.data = 5;
b = a1;
a2 = b;
then a2 should be identical to a1 and b should be 6.
First off I can''t get this to compile because ClassB isn''t know ClassA
at compile time...
Is it necesary to have int data in both classes or can A inherit from B
and vise versa?
Can both the casting operators exist in only on of the classes?
I guess this is very similar to:
float a1, a2;
int b;
a1 = 5.0
b = a1;
a2 = b;
Of course there is a loss of percision in this case.. but the casting
operations work...
help?
TIA
JustSomeGuy wrote:I have two object types ClassA and ClassB
<snip>
First off I can''t get this to compile because ClassB isn''t know ClassA
at compile time...
Is it necesary to have int data in both classes or can A inherit from
B and vise versa?
Can both the casting operators exist in only on of the classes?
<snip>
I fixed a few logic errors also (ClassB''s operator ClassA returned a
ClassB):
class ClassB;
class ClassA {
public:
int data;
operator ClassB();
};
class ClassB {
public:
int data;
operator ClassA();
};
ClassA::operator ClassB()
{
ClassB b;
b.data = data + 1;
return (b);
}
ClassB::operator ClassA()
{
ClassA a;
a.data = data - 1;
return(a);
}
int main()
{
ClassA a1, a2;
ClassB b;
a1.data = 5;
std::cout << "a1.data == " << a1.data << std::endl;
b = a1;
std::cout << "b.data == " << b.data << std::endl;
a2 = b;
std::cout << "a2.data == " << a2.data << std::endl;
return 0;
}
- Pete
JustSomeGuy wrote:I have two object types ClassA and ClassB
class ClassA {
public:
int data;
operator ClassB()
{
ClassB b;
b.data = data + 1;
return (b);
}
};
class ClassB {
public:
int data;
operator ClassA()
{
ClassB b;
b.data = data - 1;
return(b);
You probably meant
ClassA a;
a.data = data - 1;
return a;
}
}
;
So... If I say:
ClassA a1, a2;
ClassB b;
a1.data = 5;
b = a1;
a2 = b;
then a2 should be identical to a1 and b should be 6.
First off I can''t get this to compile because ClassB isn''t know ClassA
at compile time...
Yes, that''s where you need to separate class definitions and member
function definitions:
struct B;
struct A {
int data;
operator B() const;
};
struct B {
int data;
operator A() const;
};
A::operator B() const
{
...
}
B::operator A() const
{
...
}
Is it necesary to have int data in both classes or can A inherit from B
and vise versa?
Inherit? Depends on your model.
Can both the casting operators exist in only on of the classes?
No.
I guess this is very similar to:
float a1, a2;
int b;
a1 = 5.0
b = a1;
a2 = b;
Of course there is a loss of percision in this case.. but the casting
operations work...
It''s because the conversion operators are known to the language.
Victor
"JustSomeGuy" <No***@ucalgary.ca> wrote in message
news:40***************@ucalgary.ca...I have two object types ClassA and ClassB
class ClassA {
public:
int data;
operator ClassB()
{
ClassB b;
b.data = data + 1;
return (b);
}
};
class ClassB {
public:
int data;
operator ClassA()
{
ClassB b;
b.data = data - 1;
return(b);
}
}
So... If I say:
ClassA a1, a2;
ClassB b;
a1.data = 5;
b = a1;
a2 = b;
then a2 should be identical to a1 and b should be 6.
First off I can''t get this to compile because ClassB isn''t know ClassA
at compile time...
Is it necesary to have int data in both classes or can A inherit from B
and vise versa?
Can both the casting operators exist in only on of the classes?
I guess this is very similar to:
float a1, a2;
int b;
a1 = 5.0
b = a1;
a2 = b;
Of course there is a loss of percision in this case.. but the casting
operations work...
#include <iostream>
#include <ostream>
class B;
class A
{
int data;
public:
A(int d = 0) : data (d) { }
operator B() const;
friend std::ostream& operator<<(std::ostream& os, const A& a)
{
return os << a.data;
}
};
class B
{
int data;
public:
B(int d = 0) : data (d) { }
operator A() const { return data - 1; }
friend std::ostream& operator<<(std::ostream& os, const B& b)
{
return os << b.data;
}
};
A::operator B() const { return data + 1; }
int main()
{
A a1(5);
A a2;
B b;
b = a1;
a2 = b;
std::cout << "a1 == " << a1 << ''\n''
<< "a2 == " << a2 << ''\n''
<< "b == " << b << ''\n'';
return 0;
}
Output:
a1 == 5
a2 == 5
b == 6
-Mike
这篇关于需要帮助铸造操作员......的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
