Compartilhar via

Funções <type_traits>

  • Artigo

is_assignable
is_copy_assignable
is_copy_constructible
is_default_constructible
is_move_assignable
is_move_constructible
is_nothrow_move_assignable
is_nothrow_swappable
is_nothrow_swappable_with
is_swappable
is_swappable_with
is_trivially_copy_assignable
is_trivially_move_assignable
is_trivially_move_constructible

is_assignable

Testa se um valor do tipo From pode ser atribuído a um tipo To.

template <class To, class From>
struct is_assignable;

Parâmetros

Para
O tipo do objeto que recebe a atribuição.

De
O tipo do objeto que fornece o valor.

Comentários

A expressão não avaliada declval<To>() = declval<From>() deve ser bem formada. From e To devem ser tipos completos, void ou matrizes de limite desconhecido.

is_copy_assignable

Teste se o tipo pode ser copiado na atribuição.

template <class Ty>
struct is_copy_assignable;

Parâmetros

Ty
O tipo a ser consultado.

Comentários

Uma instância do predicado de tipo será verdadeira se o tipo Ty for uma classe com um operador de atribuição de cópia; caso contrário, será falsa. Equivalente a is_assignable<Ty&, const Ty&>.

is_copy_constructible

Testa se o tipo tem um construtor de cópia.

template <class Ty>
struct is_copy_constructible;

Parâmetros

Ty
O tipo a ser consultado.

Comentários

Uma instância do predicado de tipo será verdadeira se o tipo Ty for uma classe que tem um construtor de cópia, caso contrário, será falsa.

Exemplo

#include <type_traits>
#include <iostream>

struct Copyable
{
    int val;
};

struct NotCopyable
{
   NotCopyable(const NotCopyable&) = delete;
   int val;

};

int main()
{
    std::cout << "is_copy_constructible<Copyable> == " << std::boolalpha
        << std::is_copy_constructible<Copyable>::value << std::endl;
    std::cout << "is_copy_constructible<NotCopyable> == " << std::boolalpha
        << std::is_copy_constructible<NotCopyable>::value << std::endl;

    return (0);
}

is_copy_constructible<Copyable> == true
is_copy_constructible<NotCopyable > == false

is_default_constructible

Testa se o tipo tem um construtor padrão.

template <class Ty>
struct is_default_constructible;

Parâmetros

T
O tipo a ser consultado.

Comentários

Uma instância do predicado de tipo será verdadeira se o tipo T for um tipo de classe que tem um construtor padrão; caso contrário, será falsa. Isso é equivalente ao predicado is_constructible<T>. O tipo T precisa ser um tipo completo, void ou uma matriz de limite desconhecido.

Exemplo

#include <type_traits>
#include <iostream>

struct Simple
{
    Simple() : val(0) {}
    int val;
};

struct Simple2
{
    Simple2(int v) : val(v) {}
    int val;
};

int main()
{
    std::cout << "is_default_constructible<Simple> == " << std::boolalpha
        << std::is_default_constructible<Simple>::value << std::endl;
    std::cout << "is_default_constructible<Simple2> == " << std::boolalpha
        << std::is_default_constructible<Simple2>::value << std::endl;

    return (0);
}

is_default_constructible<Simple> == true
is_default_constructible<Simple2> == false

is_move_assignable

Testa se o tipo pode ser atribuído a uma movimentação.

template <class T>
struct is_move_assignable;

Parâmetros

T
O tipo a ser consultado.

Comentários

Um tipo poderá ser atribuído a uma movimentação se uma referência rvalue ao tipo puder ser atribuída a uma referência ao tipo. O predicado de tipo é equivalente a is_assignable<T&, T&&>. Tipos atribuíveis a movimentação incluem tipos escalares referenciáveis e tipos de classe que tenham operadores de atribuição de movimentação definidos pelo usuário ou gerados pelo compilador.

is_move_constructible

Testa se o tipo tem um construtor de movimentação.

template <class T>
struct is_move_constructible;

Parâmetros

T
O tipo a ser avaliado

Comentários

Um predicado de tipo será avaliado como verdadeiro se o tipo T puder ser construído usando uma operação de movimentação. Esse predicado é equivalente a is_constructible<T, T&&>.

is_nothrow_move_assignable

Testa se o tipo tem um operador de atribuição de movimentação nothrow.

template <class Ty>
struct is_nothrow_move_assignable;

Parâmetros

Ty
O tipo a ser consultado.

Comentários

Uma instância do predicado de tipo será verdadeira se o tipo Ty tiver um operador de atribuição de movimento nothrow. Caso contrário, será falsa.

is_nothrow_swappable

template <class T> struct is_nothrow_swappable;

is_nothrow_swappable_with

template <class T, class U> struct is_nothrow_swappable_with;

is_swappable

template <class T> struct is_swappable;

is_swappable_with

template <class T, class U> struct is_swappable_with;

is_trivially_copy_assignable

Testa se o tipo tem uma cópia trivial do operador de atribuição.

template <class Ty>
struct is_trivially_copy_assignable;

Parâmetros

T
O tipo a ser consultado.

Comentários

Uma instância do predicado de tipo será verdadeira se o tipo T for uma classe que tem um operador de atribuição de cópia trivial; caso contrário, será falsa.

Um construtor de atribuição para uma classe T será trivial se for implicitamente fornecido, a classe T não tiver funções virtuais, a classe T não tiver bases virtuais, as classes de todos os membros de dados não estáticos de tipo de classe tiverem operadores de atribuição triviais e as classes de todos os membros de dados não estáticos de matriz de tipo de classe tiverem operadores de atribuição trivial.

is_trivially_move_assignable

Testa se o tipo tem um operador de atribuição de movimentação trivial.

template <class Ty>
struct is_trivially_move_assignable;

Parâmetros

Ty
O tipo a ser consultado.

Comentários

Uma instância do predicado de tipo será verdadeira se o tipo Ty for uma classe com um operador de atribuição de movimentação trivial. Caso contrário, será falsa.

Um operador de atribuição de movimentação para uma classe Ty será trivial se:

for fornecido implicitamente

a classe Ty não tiver funções virtuais

a classe Ty não tiver bases virtuais

as classes de todos os membros de dados não estáticos do tipo de classe tiverem operadores de atribuição de movimentação trivial

as classes de todos os membros de dados não estáticos da matriz de tipo da classe tiverem operadores de atribuição de movimentação trivial

is_trivially_move_constructible

Testa se o tipo tem construtor de movimentação trivial.

template <class Ty>
struct is_trivially_move_constructible;

Parâmetros

Ty
O tipo a ser consultado.

Comentários

Uma instância do predicado de tipo será verdadeira se o tipo Ty for uma classe que tem um construtor de movimentação trivial; caso contrário, será falsa.

Um construtor de movimentação de uma classe Ty será trivial se:

for implicitamente declarado

seus tipos de parâmetro forem equivalentes aos de uma declaração implícita

a classe Ty não tiver funções virtuais

a classe Ty não tiver bases virtuais

a classe não tiver membros de dados não estáticos voláteis

todas as bases diretas da classe Ty tiverem construtores de movimentação trivial

as classes de todos os membros de dados não estáticos do tipo de classe tiverem construtores de movimentação trivial

as classes de todos os membros de dados não estáticos da matriz de tipo de classe tiverem construtores de movimentação trivial

Confira também

<type_traits>