C++ 访问/更改不同类的运算符重载中的私有变量时出现问题

我对以下初始情况有一个问题： 我有两门课。例如a类和B类。在这两个类中，我有一个私有变量var。我在main中创建了这两个类的两个对象（例如obj1和obj2）。接下来，我想以obj1=obj2的形式发言。要做到这一点，我想在这个操作符重载中做一个操作符重载，我想用var做一个计算，例如

/*
--------------------------------------------------------
Header
--------------------------------------------------------
*/

#ifndef A_h
#define A_h

#include <stdio.h>
#include <iostream>

using namespace std;

/*
Definition of class A
*/
class B;
class A{
    double var;

public:
    A (double inputVar);
    A();
    A operator = (const B &rs);
    friend ostream& operator << (ostream& os, const A & obj);
};

/*
Definition of class B
*/
class B{
    double var;
    
public:
    B (double inputVar);
    B();
    B operator = (const A &rs);
    friend ostream& operator << (ostream& os, const B & obj);
};
#endif /* A_h */

---

我非常感谢每一个提示。

要访问类私有数据成员（

var

，在本例中），您应该添加一个

get（）

函数，正如@Omid CompSCI在其评论中首先指出的那样。 MWE（我保留了将给定输入加倍的赋值运算符）：

#包括
使用名称空间std；
乙级;；
/*
A类的定义
*/
甲级{
双重var；
公众：
A（双输入变量）：var（输入变量）{}
A（）：var（0）{}
A&运算符=（常数A&）；
A&运算符=（常量B&）；//新建，转换为B->A
运算符=（双精度）；//新建（&O）
friend ostream&运营商B
运算符=（双精度）；//新建（&O）
friend ostream&operator要访问类私有数据成员（
var
，在本例中），您应该添加一个
get（）
函数，正如@Omid CompSCI在其注释中首先指出的那样。
MWE（我保留了将给定输入加倍的赋值运算符）：

#包括
使用名称空间std；
乙级;；
/*
A类的定义
*/
甲级{
双重var；
公众：
A（双输入变量）：var（输入变量）{}
A（）：var（0）{}
A&运算符=（常数A&）；
A&运算符=（常量B&）；//新建，转换为B->A
运算符=（双精度）；//新建（&O）
friend ostream&运营商B
运算符=（双精度）；//新建（&O）
friend ostream&operator您还可以为覆盖
operator=
函数定义一个模板。这使您能够将a对象分配给B对象，将B对象分配给a对象。
删除中的
rs
常量

template<typename T>
A operator = (T& rs){...}

标题A.hpp

#ifndef A_h
#define A_h

#include <iostream>
#include <string>
#include "Letter.hpp"

using namespace std;

/*
Definition of class A
*/

class A : public Letter
{

    public:
    A(double inputVar)
    {
        var=inputVar;
    }
    
    A()=default;
    
    template<typename T>
    A operator = (T& rs) //removing const fixed objA1 = objA2 = objA3 = 50.5; in main.cpp
    {
        this->var = rs.get_var() * 2; // I want to do something like this
        return var;
    }
    
    friend ostream& operator<<(ostream &strm, const A &a)
    {
        strm<<a.var;
        return strm;
    }
};
#endif /* A_h */

\ifndef A\u h
#定义一个
#包括
#包括
#包括“Letter.hpp”
使用名称空间std；
/*
A类的定义
*/
A类：公开信
{
公众：
A（双输入变量）
{
var=输入var；
}
A（）=默认值；
样板
运算符=（T&rs）//删除main.cpp中的常量固定objA1=objA2=objA3=50.5
{
this->var=rs.get_var（）*2；//我想这样做
收益var；
}
friend ostream&operator您还可以为覆盖
operator=
函数定义一个模板。这使您能够将a对象分配给B对象，将B对象分配给a对象。
删除中的
rs
常量

template<typename T>
A operator = (T& rs){...}

标题A.hpp

#ifndef A_h
#define A_h

#include <iostream>
#include <string>
#include "Letter.hpp"

using namespace std;

/*
Definition of class A
*/

class A : public Letter
{

    public:
    A(double inputVar)
    {
        var=inputVar;
    }
    
    A()=default;
    
    template<typename T>
    A operator = (T& rs) //removing const fixed objA1 = objA2 = objA3 = 50.5; in main.cpp
    {
        this->var = rs.get_var() * 2; // I want to do something like this
        return var;
    }
    
    friend ostream& operator<<(ostream &strm, const A &a)
    {
        strm<<a.var;
        return strm;
    }
};
#endif /* A_h */

\ifndef A\u h
#定义一个
#包括
#包括
#包括“Letter.hpp”
使用名称空间std；
/*
A类的定义
*/
A类：公开信
{
公众：
A（双输入变量）
{
var=输入var；
}
A（）=默认值；
样板
运算符=（T&rs）//删除main.cpp中的常量固定objA1=objA2=objA3=50.5
{
this->var=rs.get_var（）*2；//我想这样做
收益var；
}
friend ostream&operator What…？添加类的定义可能更清楚。您不能使用setter/getter。还有，为什么一个对象被分配为B*2的实例，看起来很奇怪。
operator=
应该更改
这个
的内容
operator=
应该修改赋值的左侧并返回
*此
作为
A&
，不会返回新对象。但不清楚您在问什么，请显示A好吗？很抱歉我的问题定义不明确。希望通过我的编辑，问题可以理解。要访问成员，只需在
B
中添加一个getter。但这不会解决歧义问题。您可以通过使一个构造函数显式化。什么…？可以更清楚地添加类的定义。你不能使用setter/getter。还有为什么一个对象被分配为B*2的实例，这看起来很奇怪。
operator=
应该更改
的内容。这个
operator=
应该修改赋值和返回
*此
为
A&
，不返回新对象。但不清楚您在问什么，请出示A。很抱歉，我的问题定义含糊不清。希望通过我的编辑，问题可以理解。要访问成员，只需在
B
中添加一个getter。这不会解决歧义问题尽管如此。你可以通过使一个构造函数显式来解决这个问题。谢谢你的评论，我将把getter添加到我的代码中。这真的很有帮助：-）不幸的是，我必须保留主函数的语法。所以我不能将getter用于输出，我的赋值必须像
objA1=objA2=objA3=50.5；
@marcy_del：是的，我看到你的问题中的代码位发生了巨大的变化，我在那之前提交了我的答案。我想你可以使用自定义的
操作符…这意味着赋值语句只有两个边，
左=右；
不能有超过
前两个的赋值；
@marcy_del:请进行投票，如果需要，请接受答案这很有帮助。我的好奇，你是如何处理多行、一行赋值语句的？我不确定，抱歉。但我会在允许的时候在这里添加我的代码，这样你可以自己查看。谢谢你的评论。我会在代码中添加getter。这真的很有帮助：-）不幸的是，我必须保留语法所以我不能用getter作为输出，我的作业必须像
objA1=objA2=objA3=50.5；
@marcy\u del:是的，我看到你的问题中的代码位有了很大的改变，我在那之前提交了我的答案。我想你可以使用自定义的
操作符…意思是作业
#include <iostream>

using namespace std;

class B;

/*
Definition of class A
*/
class A{
    double var;

public:
    A (double inputVar): var(inputVar) {}
    A(): var(0) {}
    A& operator = (const A &);
    A& operator = (const B &);   // new, converts B->A
    A& operator = (double);      // new
    friend ostream& operator << (ostream&, const A &);

    double get() const {return var;}
};

/*
Definition of class B
*/
class B{
    double var;

public:
    B (double inputVar): var(inputVar) {}
    B(): var(0) {}
    B& operator = (const B &);
    B& operator = (const A &);      // new, converts A->B
    B& operator = (double);         // new
    friend ostream& operator << (ostream&, const B &);
    double get() const {return var;}
};

A& A :: operator = (const A & rs) {
    if (this == &rs)
        return *this;       // make sure you aren't self-assigning
    this->var = rs.var * 2;
    return *this;
}
B& B :: operator = (const B & rs) {
    if (this == &rs)
        return *this; 
    this->var = rs.var * 2;
    return *this;
}
A& A :: operator = (const B & rs) {
    this->var = rs.get() * 2;
    return *this;
}
B& B :: operator = (const A & rs) {
    this->var = rs.get() * 2;
    return *this;
}
A& A :: operator = (double rs) {
    this->var = rs * 2;
    return *this;
}
B& B:: operator = (double rs) {
    this->var = rs * 2;
    return *this;
}

/*
main
*/
int main()
{
    A objA1;
    A objA2 (20.4);
    A objA3=25;

    B objB1;
    B objB2(20.4);

    objA3=objB2;
    cout << "objA3 contents, " << objA3.get() 
         << ", are equal to 2*objB2's: " << objB2.get() << endl;

    objA1 = 50.5;
    objA2 = objA1;
    objA3 = objA2;
    cout << "Now objA1: " << objA1.get() 
         << ", objA2: " << objA2.get() << ", and objA3: " << objA3.get() << endl;
}

template<typename T>
A operator = (T& rs){...}

#ifndef Letter_h
#define Letter_h

class Letter
{
    public:
    double get_var() const
    {
        return var;
    }
    protected:
    double var;
};
#endif /* Letter_h */

#ifndef A_h
#define A_h

#include <iostream>
#include <string>
#include "Letter.hpp"

using namespace std;

/*
Definition of class A
*/

class A : public Letter
{

    public:
    A(double inputVar)
    {
        var=inputVar;
    }
    
    A()=default;
    
    template<typename T>
    A operator = (T& rs) //removing const fixed objA1 = objA2 = objA3 = 50.5; in main.cpp
    {
        this->var = rs.get_var() * 2; // I want to do something like this
        return var;
    }
    
    friend ostream& operator<<(ostream &strm, const A &a)
    {
        strm<<a.var;
        return strm;
    }
};
#endif /* A_h */

#ifndef B_h
#define B_h

#include <iostream>
#include <string>
#include "Letter.hpp"

using namespace std;

/*
Definition of class B
*/

class B : public Letter 
{

    public:
    B(double inputVar)
    {
        var=inputVar;
    }
    
    B()=default;
    
    template<typename T>
    B operator = (const T &rs)
    {
        return this->var;
    }
    
    friend ostream& operator<<(ostream &strm, const B &b)
    {
        strm<<b.var;
        return strm;
    }
};

#include <iostream>
#include "A.hpp"
#include "B.hpp"

using namespace std;

int main(int argc, const char * argv[]) {
   A objA1;
   A objA2 (20.4);
   A objA3=25;
   A objA4=26;

   B objB1;
   B objB2(20.4);
   B objB3=25;

   objA2=objB2;
   
   objB3=objA4;
   
   objA1 = objA2 = objA3 = 50.5;
    
    cout << objA2 << endl;
    cout << objB2 << endl;
    cout << objA3 << endl; 
    cout << objB3 << endl; 
    
    return 0;
}