Discussion :

[pitichamo]

Bonjour à tous,
j'aimerais savoir plus sur les fonctions du style

Code :

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

int* fonction (type parm1, type parm2);

est-ce-que c'est la meme chose que de faire :

Code :

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

int (*fonction)(type parm1, type parm2);

ou est-ce-que c'est autre chose que j'aime pas compris

[Bousk]

Bonjour,

ça n'a strictement rien à voir.
Dans le premier cas, tu déclares une fonction qui retourne un int* et prend 2 paramètres.
Dans le second cas, tu déclares un pointeur sur une fonction retournant un int et qui prend 2 paramètres.

[Davidbrcz]

Le premier est le prototype d'une fonction à 2 arguments renvoyant un pointeur sur un entier.

Le second est un pointeur de fonction nommé "fonction" qui pourra être affecté a une fonction libre renvoyant un int et prenant 2 arguments.

Edit: grillé

[pitichamo]

dans le deuxième cas j'ai compris comment faire mais dans le premier
est ce que j'ai ce que j'aurais :

Code :

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

1
2
3
4
5
6
 
int* fonction (type parm1, type parm2)
{
/*code de la fonction */
return *quelquechose;
}

et dans ce cas comment ce fait l'appel de la fonction ?
--je suis pommé --

[Davidbrcz]

Comme n'importe qu'elle fonction

Code :

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

1
2
3
4
5
6
7
8
int* f(int, int)
{
int* r=0;
//bla bla
return r;
}
 
int* q= f(2,3);

[jblecanard]

dans le deuxième cas j'ai compris comment faire mais dans le premier

J'ai comme un doute . La notion de pointeur sur un int est plus facile à maîtriser que celle de pointeur sur fonction.

Regarde ce bout de code commenté, j'espère qu'il t'aidera à mieux comprendre :

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
// Déclaration d'une fonction ( à mettre dans le *.h)
int* fonction(int parm1, int parm2);
 
// Implémentation de la fonction ( à mettre dans le *.cpp)
int* fonction(int parm1, int parm2)
{
  int * resultat = new int;
  *resultat = parm1 + parm2;
  return resultat;
}
 
int autre_fonction(int i1, int i2)
{
  return i1*i2;
}
 
int main(int argc, char* argv[])
{ 
  // Usage de la fonction qui renvoie un pointeur sur un int
  int * p1 = fonction(1,2);
  if(p1)
    delete p1;
 
  // Ceci est une variable, on déclare un pointeur de fonction
  int (*fonction_ptr)(int parm1, int parm2);
  // Usage du pointeur de fonction
  fonction_ptr = autre_fonction;
  // Appel de ce pointeur
  int resultat = (*fonction_ptr)(3,4);
 
  return 0;
}

Je pense que tu devrais lire un cours sur les pointeurs, ça t'aidera beaucoup.

[3DArchi]

Je pense que tu devrais lire un cours sur les pointeurs, ça t'aidera beaucoup.

+1.
Je pense qu'avant d'aborder les pointeurs, il serait intéressant de renforcer les connaissances de base du C++.

[pitichamo]

c'est ce que j'essaie de faire mais les pointeurs y a de quoi devenir fous pour BIEN comprendre ..

[pitichamo]

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
// Déclaration d'une fonction ( à mettre dans le *.h)
int* fonction(int parm1, int parm2);
 
// Implémentation de la fonction ( à mettre dans le *.cpp)
int* fonction(int parm1, int parm2)
{
  int * resultat = new int;
  *resultat = parm1 + parm2;
  return resultat;
}
 
int autre_fonction(int i1, int i2)
{
  return i1*i2;
}
 
int main(int argc, char* argv[])
{ 
  // Usage de la fonction qui renvoie un pointeur sur un int
  int * p1 = fonction(1,2);
  if(p1)
    delete p1;
 
  // Ceci est une variable, on déclare un pointeur de fonction
  int (*fonction_ptr)(int parm1, int parm2);
  // Usage du pointeur de fonction
  fonction_ptr = autre_fonction;
  // Appel de ce pointeur
  int resultat = (*fonction_ptr)(3,4);
 
  return 0;
}

Je pense que tu devrais lire un cours sur les pointeurs, ça t'aidera beaucoup.

en fait une semaine après je me rend compte que y a un petit souci avec ce code; dans la fonction dont le prototype est : int* fonction(int parm1, int parm2);
tu as initialisé int resultat en local et c'est cette meme variable qui sera retournée; dans ce cas la des que le code sort de la fonction la variable resultat n'est plus valide donc faut la mettre en globale ce qui sera mieux.


merci beaucoup pour votre aide

[Bousk]

Bonjour,

le code est tout à fait correct.
L'as-tu essayé pour remarquer l'erreur ?
resultat est un pointeur auquel on alloue de la mémoire avec new dont on retourne l'adresse, à la sortie de la fonction la mémoire allouée n'est pas supprimée et l'adresse retournée est tout à fait valide et utilisable, ainsi que la valeur pointée.

[koala01]

Salut,

en fait une semaine après je me rend compte que y a un petit souci avec ce code; dans la fonction dont le prototype est : int* fonction(int parm1, int parm2);
tu as initialisé int resultat en local et c'est cette meme variable qui sera retournée; dans ce cas la des que le code sort de la fonction la variable resultat n'est plus valide donc faut la mettre en globale ce qui sera mieux.

Ca va pas, non

la duré de vie d'une valeur de retour est étendue à la portée dans laquelle la variable qui la récupère se trouve, autrement, il n'y aurait aucun intérêt à renvoyer une valeur

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
 
int foo(int fisrt, int second)
{
    int i = first * second;
    return i;
}
int * bar(size_t size)
{
    int * ptr = new int[size];
    return ptr;
}
int main()
{
    int value;
    int myptr = 0;
    value  = foo(5, 7);
    myptr = bar(3);
    /* ... */
    delete [] myptr;
    return 0;
}

est donc un code tout à fait valide et correct!!!

Il n'y aura problème que si l'on essaye de renvoyer une référence ou un pointeur sur une variable locale à la fonction:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
std::string /* const */ & concat(std::string const & first, std::string const & second)
{
    std::string result;
    result = first + second;
    return result; // on renvoie une référence sur result, mais
} // result est détruit ici, la référence est donc invalide
 
int * truc( int first, int second)
{
    int temp = first + second;
    return & temp; // on renvoye un pointeur sur temp mais
}// temp est détruit ici : on renvoie donc un pointeur qui posera
 // problème plus tard (car l'adresse mémoire peut etre utilisée 
 // pour autre chose)

Ceci dit, pour bien comprendre les pointeurs, il "suffit" de te dire qu'un pointeur n'est rien de plus qu'une valeur numérique un peu particulière en cela qu'elle contient en réalité l'adresse mémoire à laquelle on va trouver une variable du type précisé.

Il faut en effet te dire que toute "chose" utilisée dans un programme se trouve à une adresse mémoire donnée (je dis chose parce que, si on se doute que c'est le cas pour une variable, il est peut etre moins évident de comprendre que c'est aussi le cas pour les fonctions )

On peut donc demander d'obtenir l'adresse mémoire de toute chose, et cela se fait sur un pointeur

Comme un pointeur n'est jamais qu'une valeur numérique "classique", il sera possible d'effectuer certaines opérations mathématique (essentiellement l'addition et la soustraction), mais, comme la valeur représentée est l'adresse mémoire à laquelle se trouve (ou plutôt, à laquelle est sensée se trouver) une variable du type précisé, tu te doutes que la multiplication ou la division n'auront pas de sens

Il existe trois raisons pour vouloir utiliser un pointeur (et donc l'adresse mémoire à laquelle se trouve une variable donnée)

1. parce que l'on souhaite prendre en charge la responsabilité de la durée de vie d'une variable
2. parce que l'on veut utiliser l'adresse comme étant celle à laquelle se trouve le premier élément d'un ensemble contigus d'éléments de même type (tableau "C style")
3. parce que l'on veut transmettre à une fonction un objet pour lequel les éventuelles modifications que l'on apporterait (dans la fonction) seraientrépercutées à l'objet d'origine ET que l'objet en question peut ne pas exister.

Je pourrais disserter sur ces trois points pendant assez longtemps, mais je vais m'en tenir là pour l'instant