Discussion :

[B65AcR]

Bonjour,

J'ai besoin d'une fonction qui laisse le choix à l'utilisateur de créer une variable de type maClasse, et dans ce cas la renvoie par un return, ou si l'utilisateur en decide autrement, la fonction renvoie un int.

Le code ci dessous ne compile pas et j'ignore pourquoi. (il ne se sert même pas du destructeur d’ailleurs. Pourquoi?)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <iostream>
#include <stdio.h>
using namespace std;
 
 
class maClasse
{
 
public:
    int a;
    maClasse()
    {
        a=555;
        cout << "constructeur\n";
    }
    ~maClasse()
    {
        cout << "destructeur\n";
    }
 
template <class maClasse>
maClasse TestRetour()
{
    return 1;
}
};
 
main()
{
maClasse *C = new maClasse;
 
cout << C->a << endl;
C->TestRetour();
 
}

Quelqu'un pourrait m'aider a me servir des templates?

Une autre solution existe peut être?

Merci par avance

[Neckara]

Bonjour,

Il faut que le compilateur puisse savoir quel argument est passé au template :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template <typename T>
void foo(void)
{
        //....
}
 
foo<int>();
 
// ou
template <typename T>
void foo(T a)
{
         // ....
}
foo(45);

[Iradrille]

Le code ci dessous ne compile pas et j'ignore pourquoi.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
template <class maClasse>
maClasse TestRetour()
{
    return 1;
}

Ça ne compile pas parce qu'un int (1) n'est pas convertible en "maClasse".

il ne se sert même pas du destructeur d’ailleurs. Pourquoi?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

maClasse *C = new maClasse;

Le destructeur sera appelé lors d'un delete C;.
(Attention aux fuites mémoire)

J'ai besoin d'une fonction qui laisse le choix à l'utilisateur de créer une variable de type maClasse, et dans ce cas la renvoie par un return, ou si l'utilisateur en decide autrement, la fonction renvoie un int.

J'ai pas l'impression que les templates soient utiles pour ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
maClasse testRetour(const maClasse& arg) const {
     return arg; // copie ici, je me demande si dans ce cas particulier retourner une ref constante est safe.
}
 
int testRetour() const {
     return 1;
}

Tu as au final 2 fonctions bien distinctes : 1 qui prend un "maClasse en argument et 1 qui ne prend pas d'argument.

Ou peut être que tu cherches à faire quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template <class T>
T createOrReturnInt() const;
 
template <>
int createOrReturnInt<int>() const {
    return 1;
}
 
template <>
maClasse createOrReturnInt<maClasse>() const {
    return maClasse();
}
 
// niveau utilisation
maClasse a;
auto b = a.createOrReturnInt<int>(); // b de type int
auto c = a.createOrReturnInt<maClasse>(); // c de type maClasse
auto d = a.createOrReturnInt<float>(); // erreur de link

Mais j'ai du mal à voir l'intéret d'une telle fonction.

En créant la fonction différemment on peut arriver à quelque chose du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class maClasse {
public:
	int a;
	maClasse(): a(555) { std::cout << "constructeur\n"; }
	~maClasse() { std::cout << "destructeur\n"; }
 
	template <bool>
	struct createOrReturnInt {
		static int exec() { return 1; }
	};
 
	template <>
	struct createOrReturnInt<true> {
		static maClasse exec() { return maClasse(); }
	};
};
 
// utilisation
auto a = maClasse::createOrReturnInt<true>::exec(); // a de type maClasse
auto b = maClasse::createOrReturnInt<false>::exec(); // b de type int

C'est peut être ce que tu cherches à faire ?

[B65AcR]

Merci pour vos réponses très complète.

Si on cré 2 fonctions surchargées, est-ce bien utile de passer par les templates?

Là ce n'était qu'un bout de code de test. la vrai fonction proposera a l'utilisateur de créer une classe et de l'ajouter a un vecteur, choix qu'il pourra refuser. j'ai alors besoin de connaitre sa decision par le renvoit d'un booleen ou autre.

La solution que j'ai pour l'instant trouvé est de faire un push vers le vecteur si la variable est crée.

[oodini]

Si on cré 2 fonctions surchargées, est-ce bien utile de passer par les templates ?

Oui, parce que pour faire une surcharge, il faut que les signatures des fonctions diffèrent par leurs arguments.
Or, le type de retour ne fait pas partie de la signature. Celles-ci sont donc identiques pour les deux fonctions.

Voir cette entrée de la FAQ.

[Iradrille]

la vrai fonction proposera a l'utilisateur de créer une classe et de l'ajouter a un vecteur, choix qu'il pourra refuser. j'ai alors besoin de connaitre sa decision par le renvoit d'un booleen ou autre.

Il est du coup inutile de retourner un type inconnu, c'est un simple if

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
bool askUser() {
   std::cout << "add ? (o/n)";
   char c;
   std::cin >> c;
   return c == 'o';
}
 
void addIfUserWant(std::vector<maClasse>& vec) {
    if(askUser()) {
        vec.emplace_back(/* ... */);
    }
}