šablony a ukazatele – C / C++ – Fórum – Programujte.com

Dobrý večer přeji

Ještě před nedávnem jsem šablony absolutně neovládal. Nyní alespoň už trochu tuším o co se jedná. Prosím o drobné posunutí mého poznání osvětlením tohoto:
 

#include <iostream>

template<typename T> void zobraz(const T &);

int main()
{
	auto prom_int = 7;
	auto prom_long = 7L;
	auto prom_p_int = &prom_int;

	zobraz(prom_int);
	zobraz(prom_long);
	zobraz(prom_p_int);
	return 0;
}

template<typename T> void zobraz(const T & ob)
{
	std::cout << ob << " " << sizeof ob << std::endl;
}

U tohoto jsem se chtěl přesvědčit, že auto dělá co má, ale to není podstatné. Problémem u mě je to, že jsem se snažil vytvořit novou šablonu pro zobraz. Něco ve stylu 

  

template<typename T> void zobraz(const T * p_ob)
{
	std::cout << p_ob << " " << *p_ob; 
	std::cout << " " << sizeof *p_ob << std::endl;
}

Moje představa byla, že se pozná, že se při volání zobraz(prom_p_int) pozná, že se jedná o ukazatel a použije se druhá šablona. To jak jsem si všiml se neděje, prosím tedy o odpovědi na tyto otázky:

1)  byla by vůbec někdy použita "nová" šablona?
2) lze nějak zařídit, aby pro libovolný ukazatel byla použita jedna šablona a pokud se o ukazatel nejedná, pak druhá?

pozn.: Jsem ve všem začátečník, doufám proto že jsem dotaz zformuloval srozumitelně. Každopádně díky za každou odpověď

Normálně zobrazíš jen adresu pointeru.

Pokud chceš obsah, tak musíš použít dereferenci ve volání zobraz.

Případně asi explicitní specializace.

#2 KIIV
Díky za odpověď.

Pokud bych ve volání na zobraz použil dereferenci pak by se normálně použila první šablona. Ta druhá, která byla zamýšlená pro ukazatele (a která obsahuje zároveň zobrazení adresy a dereferencovaného pointeru) by se stejně nepoužila.

Ten dotaz byl původně myšlen takto. Zmíněná explicitní specializace možná problém řeší, ale neznám ji ještě. Alespoň už vím co se mám teď chvíli učit.

Instancivanie templatov funguje nasledovne:

//mas template funkcie:

template<typename T> 
void zobraz(const T& );

template<typename T> 
void zobraz(const T* );

//Ak zavolas funkciu zobraz s mutable value premennou:
int i;

fnc(i); 
//tak sa vygeneruju nasledovne funkcie:
void zobraz(const int&);        //1
void zobraz(/*error*/);	        //2: tato funkica sa zahodi vdaka SFINAE

//zavola sa funkcia 1.

//Ak zavolas funkciu zobraz z mutable pointerom:
int i;

zobraz(&i);    

//vygeneruju sa tieto 2 funkcie:
void zobraz(const int*&); 	//1
void zobraz(const int* );	//2

//obe funkcie akceptuju typ int* po pretypovani na const int*, ale funkcia 1 ho bere ako refrenciu, cize ma vyzsiu prioritu pri overloadingu.

//Ak zavolas funkciu s const pointrom:
const int i;

zobraz(&i);
//vygeneruju sa nasledovne funkcie:
zobraz(const int*&);	//1
zobraz(const int*);	//2

//obe funkcie sa mozu pouzit, ale funkcia 2. akceptuje parameter &i typu const int* BEZ PRETYPOVANIA, cize ma vyzsiu prioritu ako funkcia 1.

Ak chces aby sa pre pointre vzdy volala 1 funkcia a pre ostatne hodnoty druha, tak potrebujes parametre bez const:

template<typename T> 
void zobraz(T*);

template<typename T> 
void zobraz(T&&);	//akceptuje referencie a rvalue referencie (vyzaduje c++11/c++14)

//obe funkcie akceptuju aj const parametre!


//pripadne mozes spravyt overloading vsetkych 4 verzii:

template<typename T> 
void zobraz(T*);

template<typename T> 
void zobraz(const T*);

template<typename T> 
void zobraz(T&);

template<typename T> 
void zobraz(const T&);