Discussion :

[oranoutan]

Bonjour,

Voila un peut près ce que je souhaiterai faire, mais ça ne passe pas :

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
#include "stdio.h"
 
 
struct _test {
	int x;
	int y;
	int *p;
};
typedef struct _test test;
 
int main()
{
	test ts;
 
	ts.x = 4;
	ts.y = 2;
	ts.p = &ts.y;
 
	printf("%i", add(ts.x, ts.y, ts.p));
 
	return 0;
}
 
int add(int x, int y, int *p)
{
	return x+y+(*p);
}

[souviron34]

déjà printf("%d" serait pas mal..

et

Code :

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

	ts.p = &(ts.y);

aussi

[aoyou]

Et si tu rajoutais une seconde parenthèse à la fin de printf...

déjà printf("%d" serait pas mal..

%d ou %i c'est pareil mais on utilise plus couramment %d effectivement.

Ce serait mieux que tu déclares (par forcément définisses) add avant main.

[Thierry Chappuis]

En déclarant la fonction add(), et en faisant attention à ne pas oublier de parenthèses, on a:

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
#include <stdio.h>
#include <stdlib.h>
 
typedef struct test_ {
	int x;
	int y;
	int *p;
} test_s;
 
int add(int x, int y, int *p);
 
int main(void)
{
	test_s ts;
 
	ts.x = 4;
	ts.y = 2;
	ts.p = &ts.y;
 
	printf("%d\n", add(ts.x, ts.y, ts.p));
 
	return EXIT_SUCCESS;
}
 
int add(int x, int y, int *p)
{
	return x + y + (*p);
}

qui fonctionne comme attendu.

Thierry

[oranoutan]

Effectivement il y avais plein de fautes, merci.

[oranoutan]

ah, j'ai encore une question, il y a t-il un avantage à utiliser un pointeur sur structure à la place ?

exemple, si on on reprend celui de Thierry :

Code :

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

1
2
3
4
5
test_s *ts;
 
au lieu de
 
test_s ts

[souviron34]

ben là la place mémoire n'est pas réservée.. Donc il te faut faire une allocation...

[Thierry Chappuis]

Code :

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

	ts.p = &(ts.y);

aussi

Certes, c'est plus plus lisible, mais

Code :

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

ts.p = &ts.y;

ou

Code :

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

ts.p = &(ts.y);

sont équivalents.

Thierry

[oranoutan]

ben là la place mémoire n'est pas réservée.. Donc il te faut faire une allocation...

C'est tout ce que ça change c'est juste l'allocation en +, au niveau de l'occupation mémoire il n'y a aucun avantage, la taille sera la même ?

[Thierry Chappuis]

ah, j'ai encore une question, il y a t-il un avantage à utiliser un pointeur sur structure à la place ?

exemple, si on on reprend celui de Thierry :

Code :

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

1
2
3
4
5
test_s *ts;
 
au lieu de
 
test_s ts

Dans ce cas, il te faut faire une allocation dynamique et ne pas oublier de libérer la mémoire alloué le cas échéant:

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
36
37
38
39
40
41
#include <stdio.h>
#include <stdlib.h>
 
typedef struct test_
{
    int x;
    int y;
    int *p;
} test_s;
 
int add(int x, int y, int *p);
 
int main(void)
{
    test_s *ts = NULL;
    int err = EXIT_SUCCESS;
 
    ts = malloc(sizeof *ts);
    if (ts != NULL)
    {
        ts->x = 4;
        ts->y = 2;
        ts->p = &(ts->y);
 
        printf("%d\n", add(ts->x, ts->y, ts->p));
 
        free(ts), ts = NULL;
    }
    else
    {
        fprintf(stderr, "Allocation de mémoire impossible!\n");
        err = EXIT_FAILURE;
    }
 
    return err;
}
 
int add(int x, int y, int *p)
{
    return x + y + (*p);
}

Il s'agit là d'une approche inutilement compliquée pour un exemple aussi simple. L'allocation dynamique de mémoire est avant tout utile lorsque qu'il s'agit de créer une structure de donnée, e.g. un tableau ou une chaîne de caractères, dont on ne connaît pas à l'avance le nombre d'éléments ou la longueur.

Thierry

[Thierry Chappuis]

C'est tout ce que ça change c'est juste l'allocation en +, au niveau de l'occupation mémoire il n'y a aucun avantage, la taille sera la même ?

Il y aura sizeof(struct test_s *) bytes de mémoire supplémentaire allouée sur la pile. Sinon, c'est tout pareil. L'allocation dynamique via malloc() est plus toutefois plus lente qu'une allocation statique.

Thierry

[souviron34]

Certes, c'est plus plus lisible, mais

Code :

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

ts.p = &ts.y;

ou

Code :

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

ts.p = &(ts.y);

sont équivalents.

Thierry

absolument...

Mais je préfère indiquer avec les parenthèses, car dès que l'on rentre dans un second niveau, ou qu'on dé-référence, les parenthèses deviennent obligatoires, et donc il me semble plus didactique de dire tout de suite avec les parenthèses, comme ça c'est homogène...

car

Code :

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

p = &ts.p.c

risque fortement de ne pas donner ce qui est attendu... surtout si c'est

Code :

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

1
2
 
p = &ts.p->c

ou

Code :

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

1
2
 
p = &ts->p.c

ou encore pire

Code :

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

1
2
 
p = &ts->p->c

[oranoutan]

Bon ok alors, il me semble avoir lu dans un tuto que le fait de passer
un pointeur en argument d'une fonction permettait d'économiser des ressources ou quelque chose dans ce genre, au lieu de faire passer des variables directement, car c'est uniquement l'adresse que l'on fait passer.

[Thierry Chappuis]

Bon ok alors, il me semble avoir lu dans un tuto que le fait de passer
un pointeur en argument d'une fonction permettait d'économiser des ressources ou quelque chose dans ce genre, au lieu de faire passer des variables directement, car c'est uniquement l'adresse que l'on fait passer.

Oui, mais ce n'est pas sous cette forme que tu as posté ta question. Effectivement, lorsqu'il s'agit de passer une structure à une fonction, utiliser un pointeur te permet d'éviter que la structure entière ne soit recopiée sur la pile. Prenons les fonctions suivantes:

Code :

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

1
2
3
4
int add(test_s t)
{
    return t.x + t.y + *(t.p);
}

et

Code :

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

1
2
3
4
5
6
7
8
9
10
int add(test_s *t)
{
    int rv = 0; /* return value */
 
    if (t != NULL)
    {
        rv = t->x + t->y + *(t->p);
    }
    return rv;
}

Dans le premier cas, la structure test_s est copiée en intégralité (le passage des arguments en C se fait par copie, toujours!) sur la pile. Tandis que dans le deuxième cas, seule l'adresse de la structure est copiée sur la pile. Selon la taille de cette dernière, cela peut engendrer une différence considérable du point de vue de la performance. Les mêmes remarques sont naturellement valables au sujet de la transmission par valeur de retour.

Thierry

[Emmanuel Delahaye]

Voila un peut près ce que je souhaiterai faire, mais ça ne passe pas :

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
#include "stdio.h"
 
struct _test {
	int x;
	int y;
	int *p;
};
typedef struct _test test;
 
int main()
{
	test ts;
 
	ts.x = 4;
	ts.y = 2;
	ts.p = &ts.y;
 
	printf("%i", add(ts.x, ts.y, ts.p));
 
	return 0;
}
 
int add(int x, int y, int *p)
{
	return x+y+(*p);
}

Le programme est court, alors procédons par étapes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c: In function `main':
main.c:19: warning: implicit declaration of function `add'
Linking console executable: console.exe
Process terminated with status 0 (0 minutes, 1 seconds)
0 errors, 1 warnings

• Pour pouvoir appeler une fonction correctement, elle doit être déclarée avant l'appel. Ici (programme monolithique : 1 seul fichier source), il suffit de la définir avant usage.
• Les identificateurs commençant par _ sont réservés à l'implémentation.
• Pour s'afficher correctement, une ligne de texte doit être termnée par un \n.

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
 
#include "stdio.h"
 
struct test
{
   int x;
   int y;
   int *p;
};
 
typedef struct test test;
 
int add (int x, int y, int *p)
{
   return x + y + (*p);
}
 
int main (void)
{
   test ts;
 
   ts.x = 4;
   ts.y = 2;
   ts.p = &ts.y;
 
   printf ("%i\n", add (ts.x, ts.y, ts.p));
 
   return 0;
}

Qu'entends-tu par "mais ça ne passe pas" ?

La fonction faut la somme des valeurs de ts.x, ts.y et ts.y (d'une façon tordue), ce qui fait 4 + 2 + 2 = 8 :

Code :

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

1
2
3
4
 
8
 
Press ENTER to continue.

[Emmanuel Delahaye]

déjà printf("%d" serait pas mal..
et

Code :

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

	ts.p = &(ts.y);

Ca ne change strictement rien.

[oranoutan]

ok c'est compris pour le pointeur de structure, merci.

Qu'entends-tu par "mais ça ne passe pas" ?

J'avais oublié une parenthèse, que j'ai édité par la suite.

Les identificateurs commençant par _ sont réservés à l'implémentation.

Qu'es ce que l'implémentation ?

[Emmanuel Delahaye]

Qu'es ce que l'implémentation ?

Un raccourci (dans ce contexte) pour "l'implémentation du langage C", c'est à dire la 'concrétisation' de ce langage (qui n'est qu'une définition abstraite dans un document) par un environnement de développement constitué de :

• Machine
• Système
• Compilateur + Editeur de liens

bref, toute la chaine qui permet de transformer un ou plusieurs fichiers source C en exécutable.

[oranoutan]

ah ok bon à savoir.