C++ 将类成员传递给无效*

我有一个简单的类，如上所示。我尝试将其对象传递给一个函数，该函数检查它们是否相等

class testClass
{
public:
    void set(int monthValue, int dayValue);
    int getMonth( );
    int getDay( );
private:
    int month;
    int day;
};

首先，我试着像

cout那样将这个（公共）方法添加到您的类中如何

obj[0].getDay() == obj[1].getDay();
obj[0].getMonth() == obj[1].getMonth();

然后，你可以这样比较：

// overloading the "==" comparison operator (no templates required in this particular case
bool operator==(const DayOfYear& otherDay) const
{
    return (month == otherDay.month) && (day == otherDay.day);
}

DayOfYear day1;
DayOfYear day2;
// ...
if (day1 == day2)  // syntactically equivalent to to: if (day1.operator==(day2))
{
    // ...
}

bool compareDates(const DayOfYear& day1, const DayOfYear& day2)
{
    return (day1.getMonth() == day2.getMonth()) && (day1.getDay() == day2.getDay());
}

编辑：由于您不想使用运算符重载，因此始终可以使用如下函数/静态方法：

// overloading the "==" comparison operator (no templates required in this particular case
bool operator==(const DayOfYear& otherDay) const
{
    return (month == otherDay.month) && (day == otherDay.day);
}

DayOfYear day1;
DayOfYear day2;
// ...
if (day1 == day2)  // syntactically equivalent to to: if (day1.operator==(day2))
{
    // ...
}

bool compareDates(const DayOfYear& day1, const DayOfYear& day2)
{
    return (day1.getMonth() == day2.getMonth()) && (day1.getDay() == day2.getDay());
}

然后，比较如下：

// overloading the "==" comparison operator (no templates required in this particular case
bool operator==(const DayOfYear& otherDay) const
{
    return (month == otherDay.month) && (day == otherDay.day);
}

DayOfYear day1;
DayOfYear day2;
// ...
if (day1 == day2)  // syntactically equivalent to to: if (day1.operator==(day2))
{
    // ...
}

bool compareDates(const DayOfYear& day1, const DayOfYear& day2)
{
    return (day1.getMonth() == day2.getMonth()) && (day1.getDay() == day2.getDay());
}

将此（公共）方法添加到类中如何

obj[0].getDay() == obj[1].getDay();
obj[0].getMonth() == obj[1].getMonth();

然后，你可以这样比较：

// overloading the "==" comparison operator (no templates required in this particular case
bool operator==(const DayOfYear& otherDay) const
{
    return (month == otherDay.month) && (day == otherDay.day);
}

DayOfYear day1;
DayOfYear day2;
// ...
if (day1 == day2)  // syntactically equivalent to to: if (day1.operator==(day2))
{
    // ...
}

bool compareDates(const DayOfYear& day1, const DayOfYear& day2)
{
    return (day1.getMonth() == day2.getMonth()) && (day1.getDay() == day2.getDay());
}

编辑：由于您不想使用运算符重载，因此始终可以使用如下函数/静态方法：

// overloading the "==" comparison operator (no templates required in this particular case
bool operator==(const DayOfYear& otherDay) const
{
    return (month == otherDay.month) && (day == otherDay.day);
}

DayOfYear day1;
DayOfYear day2;
// ...
if (day1 == day2)  // syntactically equivalent to to: if (day1.operator==(day2))
{
    // ...
}

bool compareDates(const DayOfYear& day1, const DayOfYear& day2)
{
    return (day1.getMonth() == day2.getMonth()) && (day1.getDay() == day2.getDay());
}

然后，比较如下：

// overloading the "==" comparison operator (no templates required in this particular case
bool operator==(const DayOfYear& otherDay) const
{
    return (month == otherDay.month) && (day == otherDay.day);
}

DayOfYear day1;
DayOfYear day2;
// ...
if (day1 == day2)  // syntactically equivalent to to: if (day1.operator==(day2))
{
    // ...
}

bool compareDates(const DayOfYear& day1, const DayOfYear& day2)
{
    return (day1.getMonth() == day2.getMonth()) && (day1.getDay() == day2.getDay());
}

您可以在类中添加friend函数：

DayOfYear day1;
DayOfYear day2;
// ...
if (compareDates(day1, day2))
{
    // ...
}

#包括
使用名称空间std；
上课日
{
公众：
无效集（int monthValue，int dayValue）{
月=月值；
日=日值；
}
friend bool比较（DayOfYear和d1、DayOfYear和d2）{
返回（d1.getDay（）==d2.getDay（））&&（d1.getMonth（）==d2.getMonth（））；
}
int getMonth（）{return month；}
int getDay（）{return day；}
私人：
整月；
国际日；
};
int main（）{
OfYear obj[3]；
obj[0].集（1,1）；
obj[1].集（1,1）；
obj[2].集（1,1）；
if（比较（obj[0]，obj[1]））{
cout您可以在类中添加友元函数：

DayOfYear day1;
DayOfYear day2;
// ...
if (compareDates(day1, day2))
{
    // ...
}

#包括
使用名称空间std；
上课日
{
公众：
无效集（int monthValue，int dayValue）{
月=月值；
日=日值；
}
friend bool比较（DayOfYear和d1、DayOfYear和d2）{
返回（d1.getDay（）==d2.getDay（））&&（d1.getMonth（）==d2.getMonth（））；
}
int getMonth（）{return month；}
int getDay（）{return day；}
私人：
整月；
国际日；
};
int main（）{
OfYear obj[3]；
obj[0].集（1,1）；
obj[1].集（1,1）；
obj[2].集（1,1）；
if（比较（obj[0]，obj[1]））{
cout在您编写的compare_类函数中，您正在比较实际对象的地址。这在对象相等性方面并不意味着什么。函数应该返回什么？如果对象相等？它的编写方式是：如果对象的位置不同-返回true；如果位置相同-return false，它与您想要的相反

由于您没有在类中使用任何指针，并且不想使用运算符重载，请签出。用法如下：

#include <iostream>
using namespace std;
class DayOfYear
{
public:
void set(int monthValue, int dayValue) {
    month = monthValue;
    day = dayValue;
}

friend bool compare(DayOfYear&d1,DayOfYear&d2) {

    return (d1.getDay() == d2.getDay()) && (d1.getMonth() == d2.getMonth());
}

int getMonth( ) { return month; }

int getDay( ) { return day; }

private:
int month;
int day;
};

int main(){

DayOfYear obj[3];
obj[0].set(1,1);
obj[1].set(1,1);
obj[2].set(1,1);


if(compare(obj[0],obj[1])){
    cout<<"Match"<<endl;
}


return 0;
}

在您编写的compare_类函数中，您正在比较实际对象的地址。这在对象相等性方面并不意味着什么。函数应该返回什么？如果对象相等？它的编写方式是：如果对象的位置不同-返回true；如果位置相同-返回false，与您想要的相反

由于您没有在类中使用任何指针，并且不想使用运算符重载，请签出。用法如下：

#include <iostream>
using namespace std;
class DayOfYear
{
public:
void set(int monthValue, int dayValue) {
    month = monthValue;
    day = dayValue;
}

friend bool compare(DayOfYear&d1,DayOfYear&d2) {

    return (d1.getDay() == d2.getDay()) && (d1.getMonth() == d2.getMonth());
}

int getMonth( ) { return month; }

int getDay( ) { return day; }

private:
int month;
int day;
};

int main(){

DayOfYear obj[3];
obj[0].set(1,1);
obj[1].set(1,1);
obj[2].set(1,1);


if(compare(obj[0],obj[1])){
    cout<<"Match"<<endl;
}


return 0;
}

如果你不想通过
foo-foo2
进行比较，那就做点别的吧。我非常怀疑这样一种假设，即你试图做的任何事情都应该以一种需要空指针的方式来完成。你不需要模板来做操作符重载。你的
compare\u类
函数对于一个非常基本的问题来说是一个非常糟糕的解决方案m、 如果您只是立即将参数转换为
DayOfYear*
，为什么您要传递
void*
参数？为什么您认为您需要
void*
？这是无中生有的。这是一个非常糟糕的主意。从编译器中删除类型检查功能，从而消除识别错误的可能性。您完全偏离了轨道。永远不要（！）使用类型省略（void*），除非你必须这样做。如果你不想通过
foo-foo2
进行比较，那么就做其他事情。我非常怀疑这样一种假设，即你试图做的任何事情都应该以一种需要空指针的方式来做。你不需要模板来进行运算符重载。你的
compare\u class
函数是一个非常糟糕的解决方案o一个非常基本的问题。如果您直接将
void*
参数强制转换为
DayOfYear*
，为什么您认为需要
void*
？这是一个不知从何而来的问题。这是一个非常糟糕的主意。从编译器中删除类型检查功能，从而消除识别错误的可能性。您是完全错误的不要（！）使用类型省略（void*），除非你必须这样做。@itsnotmyrealname，那么，如果你确信它成功了，就投吧。@itsnotmyrealname：为什么你不能使用它？这是正确的解决方案。@itsnotmyrealname，那么，如果你确信它成功了，就投吧。@itsnotmyrealname：为什么你不能使用它？这是正确的解决方案。你是在认真地向一个我认识的初学者建议
memcmp
what’所有的指针废话都已经走上了错误的轨道？哇。不要因为你是第一个在这里提到同一性和平等性之间的区别而放弃投票。@ChristianHackl他明确表示，他希望在不使用运算符重载的情况下比较两个对象。从我所看到的每一个建议都包含在一个w中是的，或者其他-与运算符重载有关。这个解决方案没有使用运算符重载，所以我认为它是对OPs问题的直接回答。你是认真地向一个已经在错误轨道上使用指针废话的初学者建议
memcmp
？哇。不要因为你是第一个到这里来投票的人而放弃投票o提到恒等式和相等式之间的区别。@ChristianHackl他明确表示，他希望在不使用运算符重载的情况下比较两个对象。从我所看到的每个建议都以某种方式与运算符重载有关。这个解决方案没有使用运算符重载，所以我认为它是直接的对问题的答复。