Ebben a tananyagrészben típusokkal kapcsolatos utasításokról lesz szó.

előző tananyagrész: alapvető típuskonverziók
következő tananyagrész: elágazások, logikai kifejezések

• CppCon 2014: Scott Meyers "Type Deduction and Why You Care" (videó)

auto kulcsszó

C++11 és újabb szabvány szerint értelmezett forráskódban, változók, tömbök, pointerek, osztályok, templatek... satöbbi létrehozásakor (vagyis ezen dolgok definíciójában) használhatjuk az auto kulcsszót, ami a kezdőértékből kikövetkezteti hogy milyen típusú dolgot szeretnénk létrehozni. A C#-os var kulcssszóhoz hasonlítható.

Használatának előnye például az elírások elkerülése bonyolult típusok esetén, hátránya viszont az, hogy nem látjuk a definícióban, hogy a létrehozni (definiálni) kívánt dolognak mi a pontos típusa.
Nyilván az alaptípusok esetén nem túl indokolt a használata, ebben a tananyagban pedig már csak azért sem használjuk, hogy gyakoroljuk, hogy minek mi a típusa.

Néhány egyszerű példa:

//int
auto variable_example = 128;

//long int
auto variable_example2 = 128L;

//double
auto variable_example3 = 0.3;

//array of ints
auto array_exampe = {1, 2, 3, 0, 128};

• The Cherno - auto keyword (videó)
• C++ Weekly - Understanding auto (videó)
• C++ Weekly - auto All The Things (videó)

Arra viszont érdemes odafigyelni, hogy a string literálok esetén nem std::string lesz a típus, ha auto kulcsszót használunk. Ennek a típusa const char[6] lesz std::string helyett:

auto string = "hello"; //not std::string

Nem összekeverendő a C++11 előtt érvényes auto kulcsszóval, mely azt hivatott kihangsúlyozni, hogy egy változó lokális változó. Ebben a formában nagyon ritkán volt használatos az auto kulcsszó. Könnyű megkülönböztetni a fenti példától, hiszen a fenti példákban nem szerepel típus, a régi auto kulcsszót pedig típusmegjelöléssel együtt használtuk.

Pl. a main függvényen belül:

auto int variable_example = 1;

Egy kifejezés típusának lekérdezése

Bármilyen kifejezésnek lekérdezhetjük a típusát a typeid operátorral.

Ez csak egy szemléltető példa, használata fordítási hibát okoz.

//typeinfo
#include <iostream>
#include <typeinfo>

int main() {
  std::cout << typeid( /*please write some expression here*/ ).name() << '\n';}

Ez a példa viszont már működik. Néhány kifejezésnek megvizsgáljuk benne a típusát.

//typeinfo
#include <iostream>
#include <limits>
#include <typeinfo>

int main() {
  std::cout << "the type of 5.0/2: \n" << typeid( 5.0/2 ).name() << '\n';
  std::cout << "the type of 5/2: \n" << typeid( 5/2 ).name() << '\n';
  std::cout << "the type of -3 + 1u: \n" << typeid( -3 + 1u ).name() << '\n';
  std::cout << typeid( std::numeric_limits<long long int>::max() ).name() << '\n';
  std::cout << typeid( std::numeric_limits<long double>::max() ).name() << '\n';
  std::cout << typeid( sizeof(int) ).name() << '\n';
}

• cppreferencnce.com - typeid

decltype

A decltype kulcsszóval ugyanolyan típusúként deklarálhatunk valamit, mint egy másik kifejezés típusa. Ebben a példában j ugyanolyan típusú lesz, mint i:

int i;
decltype(i) j;

• cppreference.com - decltype

Typedef

A typedef-ek aliasok (álnevek, rövidítések) a típusokra és a típusmódosítókra nézve. Érdemes lehet használni őket, ha gyakran definiálunk a programunkban olyan változókat, amiket típusmódosítókkal együtt hosszú lenne kiírni (például extern unsigned long int).
Használatuk egyszerű, amikor definiálunk egy typedef-t, megmondjuk, hogy az milyen típusmódosítókat és típust helyettesítsen, és onnantól kezdve a programunkban egy változó definíciójában nem kell mindig kiírni a típusmódosítókat és a típust, hanem elég helyette leírni a typedef-et. Például:

typedef unsigned long int uli_t;
uli_t a;

előző tananyagrész: alapvető típuskonverziók
következő tananyagrész: elágazások, logikai kifejezések