C++ 获取者和设置者C++；

好了，伙计们，我的问题很简单。。我想为不同的值类型构造一个getter和setter。。基本上是函数重载，但使用getter和setter。。我是这样试的

#include <iostream>;

class Vectors {
public:
    Vectors() {};
    Vectors(int a, int b) {
        x = a, y = b;
    }
    int getX() {
        return x;
    }
    int getY() {
        return y;
    }
    float getX() {
        return (float)x;
    }
    float getY() {
        return (float) y;
    }
     friend Vectors operator+(const Vectors& v1, const Vectors& v2);
     friend Vectors operator/(const Vectors& v1, const Vectors& v2);
protected:
    int x, y;
private:

};

Vectors operator+(const Vectors& v1, const Vectors& v2) {
    Vectors brandNew;
    brandNew.x = v1.x + v2.x;
    brandNew.y = v1.y + v2.y;
    return (brandNew);
};

Vectors operator/(const Vectors& v1, const Vectors& v2) {
    Vectors brandNew(v1.x / v2.x, v1.y/v2.y);
    return brandNew;
}

int main() {
    Vectors v1(2, 3);
    Vectors v2(4, 5);
    Vectors v3;
    v3 = v1 + v2;
    Vectors v4 = v1 / v2;

    std::cout << "VECTOR 4 X : " << v4.getX() << std::endl;
    std::cout << "VECTOR 4 Y : " << v4.getY() << std::endl;

    std::cout << "Vector V3 X : " << v3.getX() << std::endl;
    std::cout << "VECTOR V3 Y : " << v3.getX() << std::endl;
}

#包括；
类向量{
公众：
向量（）{}；
向量（int a，int b）{
x=a，y=b；
}
int getX（）{
返回x；
}
int getY（）{
返回y；
}
浮点getX（）{
返回（浮动）x；
}
浮球{
返回（浮动）y；
}
友元向量运算符+（常数向量&v1，常数向量&v2）；
友元向量运算符/（常数向量&v1，常数向量&v2）；
受保护的：
int x，y；
私人：
};
向量运算符+（常量向量和v1，常量向量和v2）{
全新的载体；
brandNew.x=v1.x+v2.x；
brandNew.y=v1.y+v2.y；
返回（全新）；
};
向量运算符/（常数向量和v1，常数向量和v2）{
全新的向量（v1.x/v2.x，v1.y/v2.y）；
返回全新的；
}
int main（）{
向量v1（2,3）；
向量v2（4,5）；
向量v3；
v3=v1+v2；
向量v4=v1/v2；
std:：cout不能基于返回类型重载方法

可以在其输入参数上重载函数

例如：

void fun1(int a,char b);
void fun1(float a,char b);
void fun1(float a,int a,char b);

如果不更改我知道的参数，就无法重载函数。您需要更改函数名（称为getXFloat（）或其他名称），或者在调用函数后仅更改强制转换，如：

float the_x_value = static_cast<float>(vec.getX());

float the_x_value=static_cast（vec.getX（））；

我选择第二个选项。
另一个选项是不将结果作为返回值返回。而是：

...
void getX( float& result) const {
    result = static_cast<float>(x);
}
void getX( int& result) const {
    result = x;
}
...

。。。
void getX（浮点和结果）常量{
结果=静态铸件（x）；
}
无效getX（整数和结果）常量{
结果=x；
}
...

只是添加到选项列表中，并不是说这是最好的解决方案。
 
当然，你没有使用足够的模板。模板解决C++中的问题。使用它们。爱模板。< /P>
struct YeeTemplates {
    float F;
    template <typename T>
    T getF() { return F; }
} y;

float f = y.getF<float>();
int i = y.getF<int>();

struct YeeTemplates{
浮动F；
样板
T getF（）{return F；}
}y；
float f=y.getF（）；
int i=y.getF（）；
所以问题是？为什么不在你调用getter之后进行转换呢？问题是你如何做。它告诉我参数必须不同…@BaummitAugen。上面的代码有错误…你不能，根据你的最后一句话，这是显而易见的。如果你写
v4.getX（）
，编译器应该如何知道要调用哪个getter？同样，只需使用
int
getter并强制转换其结果。您需要两个不同的（成员）函数，其签名仅在返回类型上不同，对吗？另一个选项：查看两个++运算符（前缀与后缀）的方式是不同的。在C++中，我建议使用STATICE-CAST而不是C型铸造。你说得对，谢谢！