C++ std:：is_base_of和std:：is_可转换之间的差异

这两个模板似乎产生相同的结果。区别是什么？我们应该在什么时候使用哪个

using namespace std;

class A {

};

class B : public A {

};

class C : public A {

};

int main()
{
    cout << boolalpha << is_convertible<B, A>::value << '\n';
    cout << boolalpha << is_base_of<A, B>::value << '\n';

    cout << boolalpha << is_convertible<B, C>::value << '\n';
    cout << boolalpha << is_base_of<C, B>::value << '\n';

    return 0;
}

---

提前谢谢

查看和的文档

以下是一些区别：

#include <type_traits>

struct anything_can_convert_to {
    // This constructor constructs from anything
    template<class T> anything_can_convert_to(T&&) {}
};

struct can_convert_to_anything {
    // This conversion operator can convert to anything
    template<class T> operator T() { return *static_cast<T*>(nullptr); }
};

struct cant_convert_to_base;

struct base {
    base(const cant_convert_to_base&) = delete;
};

struct public_derived : base {};

struct private_derived : private base {};

struct cant_convert_to_base : base {};

int main() {
#define IS_CONVERTIBLE(FROM, TO) static_assert(std::is_convertible_v<FROM, TO>)
#define IS_NOT_CONVERTIBLE(FROM, TO) static_assert(!std::is_convertible_v<FROM, TO>)
#define IS_BASE_OF(BASE, DERIVED) static_assert(std::is_base_of_v<BASE, DERIVED>)
#define IS_NOT_BASE_OF(BASE, DERIVED) static_assert(!std::is_base_of_v<BASE, DERIVED>)

    IS_CONVERTIBLE(int, long);
    IS_CONVERTIBLE(int, anything_can_convert_to);
    IS_CONVERTIBLE(can_convert_to_anything, int);
    IS_NOT_CONVERTIBLE(anything_can_convert_to, int);

    IS_CONVERTIBLE(public_derived, base);
    IS_NOT_CONVERTIBLE(private_derived, base);
    IS_NOT_CONVERTIBLE(cant_convert_to_base, base);


    IS_NOT_BASE_OF(int, long);
    IS_NOT_BASE_OF(int, anything_can_convert_to);

    IS_BASE_OF(base, public_derived);
    IS_BASE_OF(base, private_derived);
    IS_BASE_OF(base, cant_convert_to_base);
}

---

格式良好。对于继承，如果

From

是

到

的基类，则大多数情况下都是这种情况，但在许多其他情况下也是这种情况（例如，对于私有继承，您无法转换为基类，但

std:：is_base_of

仍然有效。）

尝试在其他不相关的类之间定义一些转换。使用

protected

或

private

继承。或者使用基本类型测试它们，如

int

和

long

double x=1；int y=1；断言（x==y）

请解释为什么

int

和

double

都存在。@重复数据消除工具

是
的基础工具只能应用于类。我说的对吗？@Einiemand@Einiemand但是
value
只有在两种类型都是类的情况下才能
true
。。。
#include <type_traits>

struct anything_can_convert_to {
    // This constructor constructs from anything
    template<class T> anything_can_convert_to(T&&) {}
};

struct can_convert_to_anything {
    // This conversion operator can convert to anything
    template<class T> operator T() { return *static_cast<T*>(nullptr); }
};

struct cant_convert_to_base;

struct base {
    base(const cant_convert_to_base&) = delete;
};

struct public_derived : base {};

struct private_derived : private base {};

struct cant_convert_to_base : base {};

int main() {
#define IS_CONVERTIBLE(FROM, TO) static_assert(std::is_convertible_v<FROM, TO>)
#define IS_NOT_CONVERTIBLE(FROM, TO) static_assert(!std::is_convertible_v<FROM, TO>)
#define IS_BASE_OF(BASE, DERIVED) static_assert(std::is_base_of_v<BASE, DERIVED>)
#define IS_NOT_BASE_OF(BASE, DERIVED) static_assert(!std::is_base_of_v<BASE, DERIVED>)

    IS_CONVERTIBLE(int, long);
    IS_CONVERTIBLE(int, anything_can_convert_to);
    IS_CONVERTIBLE(can_convert_to_anything, int);
    IS_NOT_CONVERTIBLE(anything_can_convert_to, int);

    IS_CONVERTIBLE(public_derived, base);
    IS_NOT_CONVERTIBLE(private_derived, base);
    IS_NOT_CONVERTIBLE(cant_convert_to_base, base);


    IS_NOT_BASE_OF(int, long);
    IS_NOT_BASE_OF(int, anything_can_convert_to);

    IS_BASE_OF(base, public_derived);
    IS_BASE_OF(base, private_derived);
    IS_BASE_OF(base, cant_convert_to_base);
}

To test = (expression of type From);