使用自定义类型定义具有相同名称的多个函数 我一直在玩C++，我注意到一些我不太明白的东西： typedef浮动度数； 类型定义浮动弧度； 无效我的函数（n度）； void my_func（弧度m）；

像这样声明一个函数，我会得到一个警告，该函数被重新声明，就好像它们是相同的一样。这是否意味着，当查看函数定义时，编译器只看到内置类型，而不关心自定义定义的类型，并且由于它们是bot float，它只认为它们是同一个函数

---

如果是这样的话，我该怎么做？我只需要创建一个不同的函数吗？

您可以定义类来处理这些问题。看看这个例子：

类学位{
公众：
双角度；
度（）{}
作废我的_func（）{
//做些工作
}
};
类弧度{
公众：
双角度；
弧度（）{}
作废我的_func（）{
//做些工作
}
};
int main（）{
度；
弧度rad；
度my_func（）；
rad.my_func（）；
}

现在，它们在各自的功能中执行不同的任务

或者，如果不想创建对象，可以在这些类中创建静态函数

类弧度{
公众：
静态无效my_func（浮动弧度）{
//做些工作
}
};
类型定义浮动度；
类型定义浮动弧度；
int main（）{
弧度rad；
弧度：我的函数（rad）
}

您可以定义类来处理这些问题。看看这个例子：

类学位{
公众：
双角度；
度（）{}
作废我的_func（）{
//做些工作
}
};
类弧度{
公众：
双角度；
弧度（）{}
作废我的_func（）{
//做些工作
}
};
int main（）{
度；
弧度rad；
度my_func（）；
rad.my_func（）；
}

现在，它们在各自的功能中执行不同的任务

或者，如果不想创建对象，可以在这些类中创建静态函数

类弧度{
公众：
静态无效my_func（浮动弧度）{
//做些工作
}
};
类型定义浮动度；
类型定义浮动弧度；
int main（）{
弧度rad；
弧度：我的函数（rad）
}

typedef

仅为现有类型创建一个新名称，因此在您的示例中，编译器将度、弧度和浮点关联为相同的数据类型。例如，它们不是自定义类型，只是预先存在的类型的新名称。

typedef

仅为已存在的类型创建一个新名称，因此在您的示例中，编译器将度、弧度和浮点关联为同一数据类型。它们不是自定义类型，只是预先存在的类型的一个新名称。

问题是，对于同一类型，您没有使用两个不同的类型，而只使用两个不同的别名，因此对于编译器，它是同一个函数。

现在，解决方法有多种：

第一个类可以声明两个不同的类，其中只有一个float类型的属性，如果您希望双重实现的float的隐式转换，请按以下方式进行转换：

class Radian{
public:
  float angle;
  Radian(){};
  operator float() { return angle; }
};

另一个解决方案可以是声明两个不同的函数名，例如：

void my_func_deg(degrees n);
void my_func_rad(radians m);

或者使用内部函数创建两个不同的类：

 class Radian{
public:
  double angle;
  Radian(){};
  void my_func();
};

---

问题在于，您没有使用两种不同的类型，而是对同一类型只使用了两个不同的别名，因此对于编译器来说，它是同一个函数。

现在，解决方法有多种：

第一个类可以声明两个不同的类，其中只有一个float类型的属性，如果您希望双重实现的float的隐式转换，请按以下方式进行转换：

class Radian{
public:
  float angle;
  Radian(){};
  operator float() { return angle; }
};

另一个解决方案可以是声明两个不同的函数名，例如：

void my_func_deg(degrees n);
void my_func_rad(radians m);

或者使用内部函数创建两个不同的类：

 class Radian{
public:
  double angle;
  Radian(){};
  void my_func();
};

---

另一种可能性是定义

Radian

和

Degree

类，以便从

float

s显式转换和隐式转换

class Radian{
    float m_value;
public:
    explicit Radian(float t_value) : m_value(t_value) { }
    operator float() const { return m_value; }
};

class Degree{
    float m_value;
public:
    explicit Degree(float t_value) : m_value(t_value) { }
    operator float() const { return m_value; }
};

void my_func(Radian r);
void my_func(Degree d);

my_func(Radian(10)); // calls the Radian overload
my_func(Degree(10)); // calls the Degree overload
my_func(10); // Doesn't call either because both ctors are explicit

对

float

的隐式转换意味着您可以将

Radian

或

Degree

类型的变量传递给一个期望

float

的函数，它就可以工作了

---

此版本确实意味着，与

typedef

s不同，您将无法编写以下内容

Degree alpha = 30;
Degree beta = 60;
Degree gamma = alpha + beta; // 90 degrees

---

但是，如果需要，还可以为每个类定义算术运算符，如

运算符+

，

运算符*

，等等。例如，您可能希望始终执行度算术模运算

360

，以便

180+180=0

另一种可能是定义

Radian

和

Degree

类，从

float

进行显式转换，并对其进行隐式转换

class Radian{
    float m_value;
public:
    explicit Radian(float t_value) : m_value(t_value) { }
    operator float() const { return m_value; }
};

class Degree{
    float m_value;
public:
    explicit Degree(float t_value) : m_value(t_value) { }
    operator float() const { return m_value; }
};

void my_func(Radian r);
void my_func(Degree d);

my_func(Radian(10)); // calls the Radian overload
my_func(Degree(10)); // calls the Degree overload
my_func(10); // Doesn't call either because both ctors are explicit

对

float

的隐式转换意味着您可以将

Radian

或

Degree

类型的变量传递给一个期望

float

的函数，它就可以工作了

---

此版本确实意味着，与

typedef

s不同，您将无法编写以下内容

Degree alpha = 30;
Degree beta = 60;
Degree gamma = alpha + beta; // 90 degrees

---

但是，如果需要，还可以为每个类定义算术运算符，如

运算符+

，

运算符*

，等等。例如，您可能希望始终执行度算术模运算

360

，以便

180+180=0

您可能会看到“强类型定义”（因为您没有定义自定义类型，您正在使用不同的别名对同一类型进行浮点运算，顺便说一句，我将使用静态构造函数创建一个类

Angle

，其中包含

Degree

和

Radian

，我将使用静态构造函数

Degree

和

Radian

创建一个类

Angle

。