C++ 型比較：std::is_same, std::is_pointer, std::is_referenceを使い分ける

2024-07-27

C++ で `std::is_same<int, (int)>::value` が `false` な理由

詳細な説明:

int は基本型であり、修飾子を持っていません。
*(int*) は int 型へのポインタを表すポインタ型です。ポインタ型は、ポインタ演算子 * と & を使用できるという点で、基本型とは異なります。
std::is_same は、型が同じであるだけでなく、修飾子も同じであることを確認します。

つまり、int と *(int*) は同じ基本型 (int) を指しますが、異なる修飾子を持つため、std::is_same は false を返します。

例:

#include <iostream>
#include <type_traits>

int main() {
  std::cout << std::is_same<int, *(int*)>::value << std::endl; // false を出力
  return 0;
}

C++11 以降では、std::is_same_v という非テンプレートバージョンも使用できます。これはコンパイル時に評価されるため、パフォーマンスが向上します。
ポインタ型と参照型を比較する場合は、std::is_pointer や std::is_reference などのテンプレートを使用する必要があります。

#include <iostream>
#include <type_traits>

int main() {
  std::cout << std::boolalpha;
  std::cout << "std::is_same<int, *(int*)>::value: " << std::is_same<int, *(int*)>::value << std::endl; // Output: false

  return 0;
}

In this example, std::is_same<int, *(int*)>::value evaluates to false because int is a fundamental type without qualifiers, while *(int*) is a pointer type to int. Pointer types have different properties and operations compared to fundamental types, hence they are considered distinct even though they share the same underlying element type (int).

#include <iostream>
#include <type_traits>

int main() {
  std::cout << std::boolalpha;
  std::cout << "std::is_same<int, int&>::value: " << std::is_same<int, int&>::value << std::endl; // Output: false

  return 0;
}

Similarly, std::is_same<int, int&>::value evaluates to false because int is a fundamental type and int& is a reference type. References are aliases for objects, and they behave differently from the original type in terms of memory management and access.

Example 3: Comparing pointer types with std::is_pointer

#include <iostream>
#include <type_traits>

int main() {
  std::cout << std::boolalpha;
  int* ptr1 = nullptr;
  int* ptr2 = nullptr;

  std::cout << "std::is_same<int*, int*>::value: " << std::is_same<int*, int*>::value << std::endl; // Output: true
  std::cout << "std::is_pointer<int*>::value: " << std::is_pointer<int*>::value << std::endl; // Output: true
  std::cout << "std::is_pointer<int&>::value: " << std::is_pointer<int&>::value << std::endl; // Output: false

  return 0;
}

In this example, std::is_same<int*, int*>::value evaluates to true because both ptr1 and ptr2 are pointer types to int. However, std::is_same<int, int&>::value is still false as explained in the previous example. Additionally, std::is_pointer<int*>::value is true since int* is indeed a pointer type, while std::is_pointer<int&>::value is false because int& is a reference type.

Key takeaways:

std::is_same considers both the type and qualifiers when comparing types.
Pointer types and reference types are distinct from fundamental types even if they share the same underlying element type.
Use std::is_pointer and std::is_reference to specifically check for pointer and reference types, respectively.

Type aliases can be used to create new names for existing types. When comparing two type aliases that refer to the same underlying type, std::is_same will evaluate to true.

#include <iostream>
#include <type_traits>

using MyInt = int;

int main() {
  std::cout << std::boolalpha;
  std::cout << "std::is_same<int, MyInt>::value: " << std::is_same<int, MyInt>::value << std::endl; // Output: true

  return 0;
}

Using Typedefs:

typedef is another way to create type aliases. Similar to using type aliases directly, std::is_same will return true when comparing two typedef declarations that refer to the same underlying type.

#include <iostream>
#include <type_traits>

typedef int MyInt;

int main() {
  std::cout << std::boolalpha;
  std::cout << "std::is_same<int, MyInt>::value: " << std::is_same<int, MyInt>::value << std::endl; // Output: true

  return 0;
}

Using const and volatile Qualifiers:

When comparing types with const or volatile qualifiers, std::is_same will only return true if the qualifiers are identical. For instance, std::is_same<const int, const int> is true, but std::is_same<int, const int> is false.

#include <iostream>
#include <type_traits>

int main() {
  std::cout << std::boolalpha;
  std::cout << "std::is_same<const int, const int>::value: " << std::is_same<const int, const int>::value << std::endl; // Output: true
  std::cout << "std::is_same<int, const int>::value: " << std::is_same<int, const int>::value << std::endl; // Output: false

  return 0;
}

Using std::decay and std::remove_cv:

The std::decay template removes qualifiers (const, volatile) and pointer decay from a type. The std::remove_cv template removes const and volatile qualifiers from a type. Comparing the decayed or unqualified types using std::is_same can indicate whether the underlying types are the same.

#include <iostream>
#include <type_traits>

int main() {
  std::cout << std::boolalpha;
  const int* ptr = nullptr;

  std::cout << "std::is_same<const int*, int*>::value: " << std::is_same<const int*, int*>::value << std::endl; // Output: false
  std::cout << "std::is_same<std::decay_t<const int*>, int*>::value: " << std::is_same<std::decay_t<const int*>, int*>::value << std::endl; // Output: true
  std::cout << "std::is_same<std::remove_cv_t<const int*>, int*>::value: " << std::is_same<std::remove_cv_t<const int*>, int*>::value << std::endl; // Output: true

  return 0;
}

Using std::conditional:

The std::conditional template can be used to conditionally select a type based on a boolean condition. In this case, you can use the result of std::is_same to determine which type to use.

#include <iostream>
#include <type_traits>

template <typename T, typename U>
using SameOrDifferent = std::conditional<std::is_same<T, U>::value, T, std::string>::type;

int main() {
  SameOrDifferent<int, int> sameType;
  SameOrDifferent<int, std::string> differentType;

  std::cout << "Same type: " << typeid(sameType).name() << std::endl; // Output: int
  std::cout << "Different type: " << typeid