Apprendre Spécification de Type Implicite et Explicite

Spécification de type implicite

Dans la plupart des cas, le compilateur C++ peut automatiquement déterminer le type de modèle à partir des arguments passés à la fonction. Si les types de paramètres fournissent toutes les informations nécessaires, il n'est pas nécessaire de spécifier le type explicitement.

main.cpp


              12345678910111213
            
#include <iostream>

template<typename T>
void PrintValue(T value) { std::cout << value << std::endl; }
// The compiler assigns the type for `T` 
// Based on the type of the passed argument `value`

int main() 
{
    PrintValue(42);         // `T` is deduced as `int`
    PrintValue(3.14);       // `T` is deduced as `double`
    PrintValue("Hello");    // `T` is deduced as `const char*`
}

Le compilateur détermine automatiquement le type du paramètre de modèle T en fonction des arguments de la fonction. Cela rend les appels de fonction plus concis et plus faciles à lire. Pour cette raison, vous avez peut-être déjà utilisé des modèles sans vous en rendre compte.

main.cpp

header.h


              123456789101112
            
#include <iostream>

int main()
{
	int a = 300;
	int b = 200;

    // `std::swap` is actually a template and you can prove it
    // Try to specify `int` type explicitly `std::swap<int>`
	std::swap(a, b);
    std::cout << a << " " << b << std::endl;
}

Spécification explicite du type

Avec tout cela, une question se pose : Si la déduction de type est implicite, pourquoi s'embêter à spécifier le type explicitement ? C'est parce qu'il existe des scénarios où la déduction automatique de type ne fonctionne pas ou n'est pas suffisante, vous obligeant à spécifier le type de modèle explicitement. Jetez un œil à des exemples.

ambiguous.cpp

forcing_type.cpp

no_parameters.cpp


              12345678910
            
#include <iostream>

template<typename T>
T GetDefaultValueSum(T a, T b) { return a + b; }

int main() 
{
    // If `float` won't be specified, this code would generate an error
    std::cout << GetDefaultValueSum<float>(2, 2.5) << std::endl;
}

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 2

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Glissez pour afficher le menu

Spécification de type implicite

main.cpp


              12345678910111213
            
#include <iostream>

template<typename T>
void PrintValue(T value) { std::cout << value << std::endl; }
// The compiler assigns the type for `T` 
// Based on the type of the passed argument `value`

int main() 
{
    PrintValue(42);         // `T` is deduced as `int`
    PrintValue(3.14);       // `T` is deduced as `double`
    PrintValue("Hello");    // `T` is deduced as `const char*`
}

main.cpp

header.h


              123456789101112
            
#include <iostream>

int main()
{
	int a = 300;
	int b = 200;

    // `std::swap` is actually a template and you can prove it
    // Try to specify `int` type explicitly `std::swap<int>`
	std::swap(a, b);
    std::cout << a << " " << b << std::endl;
}

Spécification explicite du type

ambiguous.cpp

forcing_type.cpp

no_parameters.cpp


              12345678910
            
#include <iostream>

template<typename T>
T GetDefaultValueSum(T a, T b) { return a + b; }

int main() 
{
    // If `float` won't be specified, this code would generate an error
    std::cout << GetDefaultValueSum<float>(2, 2.5) << std::endl;
}

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 2

Spécification de Type Implicite et Explicite

Spécification de type implicite

Spécification explicite du type

Awesome!

Spécification de Type Implicite et Explicite

Spécification de type implicite

Spécification explicite du type