In C++ how to reuse a class definition as a different class

Say we have a class definition

class Foo {...};

I know we can reuse its definition with using or typedef

using Bar = Foo; // or typedef Foo Bar;

But they are treat as a same type, that is to say the compiler treat following as redefinition

void fun(const Foo&) { cout<<"It is Foo"<<endl; }
void fun(const Bar&) { cout<<"It is Bar"<<endl; }

Is there any possible or work around we can reuse definition that compiler treat as different types

Thanks for your solution and discussion
Here are some details of my case:
classes would declare their related type. and the type could be the same.

struct MyFoo { using type = SomeRelated; };
struct MyBar { using type = SomeRelated; };

Another class would be contructed with the related type of above classes and I want the constructor can distinguish from them

struct MyClass
{
    MyClass(const MyFoo::type&) {cout<<"ctor from MyFoo"<<endl;}
    MyClass(const MyBar::type&) {cout<<"ctor from MyBar"<<endl;}
};

</details>


# 答案1
**得分**: 4

你可以通过使用类模板来实现，模板实例始终是不同的类型。
```cpp
template <int>
class Impl {
  // 在这里实现你的 Foo
};

using Foo = Impl<1>;
using Bar = Impl<2>;

或者使用继承（你不需要记住上面使用的最后一个数字）。

template <typename>
class Impl {
  // 在这里实现你的 Foo
};

class Foo : public Impl<Foo> {};
class Bar : public Impl<Bar> {};

template <int>
class Impl {
  // Implement like your Foo here
};

using Foo = Impl<1>;
using Bar = Impl<2>;

template <typename>
class Impl {
  // Implement like your Foo here
};

class Foo : public Impl<Foo> {};
class Bar : public Impl<Bar> {};

答案2

得分: 1

这被称为强制类型定义模式/问题。存在许多部分解决方案，但大多数都考虑了基本的C++类型。对于类类型，使用继承更容易：

class foo;
class bar : public foo
{ using foo::foo; }; // 启用所有foo构造函数

对于其他类型，可以使用CRTP和装箱值的组合：

#include <type_traits>
template<typename this_type, typename value_type>
    requires(std::is_final_v<value_type> || 
         not std::is_class_v<value_type>)
struct strong_alias
{ value_type value; };

struct my_int: strong_alias<my_int,int>{};

my_int i{3};
i.value += 4;

还有其他方法可供选择，但它们通常会导致复杂且难以阅读的代码。

class foo;
class bar : public foo
{ using foo::foo; }; //enable all foo constructors

#include <type_traits>
template<typename this_type, typename value_type>
    requires(std::is_final_v<value_type> || 
         not std::is_class_v<value_type>)
struct strong_alias
{ value_type value; };

struct my_int: strong_alias<my_int,int>{};

my_int i{3};
i.value += 4;

答案3

得分: 0

你无法通过简单地使用重新定义类型来使它们不同。

但是，如果你试图将相同类型传递给同名但具有不同实现的函数，请调整函数参数签名。试用以下代码：

#include <iostream>

class foo {
};

void test(const foo&)      { std::cout << "void test(const foo&)\n"; }
void test(const foo&, int) { std::cout << "void test(const foo&, int)\n"; }

int main() {
    foo f;
    test(f);
    test(f, 0);
    return 0;
}

#include <iostream>

class foo {
};

void test(const foo&)      { std::cout << "void test(const foo&)\n"; }
void test(const foo&, int) { std::cout << "void test(const foo&, int)\n"; }

int main() {
	foo f;
	test(f);
	test(f, 0);
    return 0;
}