voilà, j'aimerais faire une fonction qui me rend un élément de type:
struct point
{
int x;
int y;
}
j'ai un cas de base du type:
if (/*ca dépend, mais ca n'est pas très important ici*/)
return /* point(-1, -1) */;
ce que je voudrais savoir, c'est quoi mettre pour avoir ce point (-1, -1).
J'ai essayé (struct point {-1, -1}); , mais gcc n'a pas apprécié.
Suis-je obligé de créer une variable pour la retourner ou existe-t-il un
moyen?
merci
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Horst Kraemer
On Fri, 30 Apr 2004 21:42:18 +0200, "Miguel" wrote:
voilà, j'aimerais faire une fonction qui me rend un élément de type:
struct point { int x; int y; }
j'ai un cas de base du type: if (/*ca dépend, mais ca n'est pas très important ici*/) return /* point(-1, -1) */;
ce que je voudrais savoir, c'est quoi mettre pour avoir ce point (-1, -1). J'ai essayé (struct point {-1, -1}); , mais gcc n'a pas apprécié. Suis-je obligé de créer une variable pour la retourner ou existe-t-il un moyen?
En C il faut créer un variable. En C++ on pourrait retourner
return point(-1,-1);
si on a défini p.ex.
struct point { point(int x, int y) : x(x),y(y) {} int x,y; };
-- Horst
On Fri, 30 Apr 2004 21:42:18 +0200, "Miguel" <mickael.i@free.fr>
wrote:
voilà, j'aimerais faire une fonction qui me rend un élément de type:
struct point
{
int x;
int y;
}
j'ai un cas de base du type:
if (/*ca dépend, mais ca n'est pas très important ici*/)
return /* point(-1, -1) */;
ce que je voudrais savoir, c'est quoi mettre pour avoir ce point (-1, -1).
J'ai essayé (struct point {-1, -1}); , mais gcc n'a pas apprécié.
Suis-je obligé de créer une variable pour la retourner ou existe-t-il un
moyen?
En C il faut créer un variable. En C++ on pourrait retourner
return point(-1,-1);
si on a défini p.ex.
struct point
{
point(int x, int y) : x(x),y(y) {}
int x,y;
};
On Fri, 30 Apr 2004 21:42:18 +0200, "Miguel" wrote:
voilà, j'aimerais faire une fonction qui me rend un élément de type:
struct point { int x; int y; }
j'ai un cas de base du type: if (/*ca dépend, mais ca n'est pas très important ici*/) return /* point(-1, -1) */;
ce que je voudrais savoir, c'est quoi mettre pour avoir ce point (-1, -1). J'ai essayé (struct point {-1, -1}); , mais gcc n'a pas apprécié. Suis-je obligé de créer une variable pour la retourner ou existe-t-il un moyen?
En C il faut créer un variable. En C++ on pourrait retourner
return point(-1,-1);
si on a défini p.ex.
struct point { point(int x, int y) : x(x),y(y) {} int x,y; };
-- Horst
Antoine Leca
En 4092ac18$0$425$, Miguel va escriure:
voilà, j'aimerais faire une fonction qui me rend un élément de type: struct point [snip]
if (/*ca dépend, mais ca n'est pas très important ici*/) return /* point(-1, -1) */;
return (struct point){-1, -1};
Nécessite un compilo C99 (gcc -stdÉ9).
Antoine
En 4092ac18$0$425$636a15ce@news.free.fr, Miguel va escriure:
voilà, j'aimerais faire une fonction qui me rend un élément de type:
struct point
[snip]
if (/*ca dépend, mais ca n'est pas très important ici*/)
return /* point(-1, -1) */;
voilà, j'aimerais faire une fonction qui me rend un élément de type: struct point [snip]
if (/*ca dépend, mais ca n'est pas très important ici*/) return /* point(-1, -1) */;
return (struct point){-1, -1};
Nécessite un compilo C99 (gcc -stdÉ9).
Antoine
JRD
Miguel wrote:
voil?, j'aimerais faire une fonction qui me rend un ?l?ment de type:
struct point { int x; int y; }
j'ai un cas de base du type: if (/*ca d?pend, mais ca n'est pas tr?s important ici*/) return /* point(-1, -1) */;
ce que je voudrais savoir, c'est quoi mettre pour avoir ce point (-1, -1). J'ai essay? (struct point {-1, -1}); , mais gcc n'a pas appr?ci?. Suis-je oblig? de cr?er une variable pour la retourner ou existe-t-il un moyen?
Bonsoir,
La question n'est pas très claire. Il faut allouer de la mémoire pour la structure pour quelle soit mise dans le "tas" (heap), sinon elle (la structure) est définie dans la "pile" (stack) et est donc perdue après la sortie de la fonction.
Voilà comment j'écrirais le code :
/* les includes pour les fonctions malloc et printf */ #include <stdio.h> #include <stdlib.h>
/* creation du "type" point (pointeur sur une structure point) */ typedef struct _point { int x; int y; } *point;
/* fonction retournant un point */ point fonction() { point ret; /* Attention a bien faire l'allocation memoire! */ ret = (point)malloc(sizeof(struct _point));
ret -> x = 2; ret -> y = -3;
return ret; }
/* pour l'exemple */ int main() { point p; /* le cast n'est pas indispensable (voire inutile) */ p = (point) fonction();
http://jerome.drapeau.free.fr La critique est aisée, l'art est difficile.
Miguel <mickael.i@free.fr> wrote:
voil?, j'aimerais faire une fonction qui me rend un ?l?ment de type:
struct point
{
int x;
int y;
}
j'ai un cas de base du type:
if (/*ca d?pend, mais ca n'est pas tr?s important ici*/)
return /* point(-1, -1) */;
ce que je voudrais savoir, c'est quoi mettre pour avoir ce point (-1, -1).
J'ai essay? (struct point {-1, -1}); , mais gcc n'a pas appr?ci?.
Suis-je oblig? de cr?er une variable pour la retourner ou existe-t-il un
moyen?
Bonsoir,
La question n'est pas très claire.
Il faut allouer de la mémoire pour la structure pour quelle soit mise
dans le "tas" (heap), sinon elle (la structure) est définie dans la
"pile" (stack) et est donc perdue après la sortie de la fonction.
Voilà comment j'écrirais le code :
/* les includes pour les fonctions malloc et printf */
#include <stdio.h>
#include <stdlib.h>
/* creation du "type" point (pointeur sur une structure point) */
typedef struct _point
{
int x;
int y;
} *point;
/* fonction retournant un point */
point fonction()
{
point ret;
/* Attention a bien faire l'allocation memoire! */
ret = (point)malloc(sizeof(struct _point));
ret -> x = 2;
ret -> y = -3;
return ret;
}
/* pour l'exemple */
int main()
{
point p;
/* le cast n'est pas indispensable (voire inutile) */
p = (point) fonction();
voil?, j'aimerais faire une fonction qui me rend un ?l?ment de type:
struct point { int x; int y; }
j'ai un cas de base du type: if (/*ca d?pend, mais ca n'est pas tr?s important ici*/) return /* point(-1, -1) */;
ce que je voudrais savoir, c'est quoi mettre pour avoir ce point (-1, -1). J'ai essay? (struct point {-1, -1}); , mais gcc n'a pas appr?ci?. Suis-je oblig? de cr?er une variable pour la retourner ou existe-t-il un moyen?
Bonsoir,
La question n'est pas très claire. Il faut allouer de la mémoire pour la structure pour quelle soit mise dans le "tas" (heap), sinon elle (la structure) est définie dans la "pile" (stack) et est donc perdue après la sortie de la fonction.
Voilà comment j'écrirais le code :
/* les includes pour les fonctions malloc et printf */ #include <stdio.h> #include <stdlib.h>
/* creation du "type" point (pointeur sur une structure point) */ typedef struct _point { int x; int y; } *point;
/* fonction retournant un point */ point fonction() { point ret; /* Attention a bien faire l'allocation memoire! */ ret = (point)malloc(sizeof(struct _point));
ret -> x = 2; ret -> y = -3;
return ret; }
/* pour l'exemple */ int main() { point p; /* le cast n'est pas indispensable (voire inutile) */ p = (point) fonction();
http://jerome.drapeau.free.fr La critique est aisée, l'art est difficile.
Régis Troadec
"Miguel" a écrit dans le message de news:4092ac18$0$425$
Salut,
voilà, j'aimerais faire une fonction qui me rend un élément de type:
struct point { int x; int y; }
Att. au point-virgule, };
j'ai un cas de base du type: if (/*ca dépend, mais ca n'est pas très important ici*/) return /* point(-1, -1) */;
ce que je voudrais savoir, c'est quoi mettre pour avoir ce point (-1, -1). J'ai essayé (struct point {-1, -1}); , mais gcc n'a pas apprécié. Suis-je obligé de créer une variable pour la retourner ou existe-t-il un moyen?
Si tu souhaites que ca tourne aussi en C90, tu seras obligé de créer une variable :
if (/*ca dépend, mais ca n'est pas très important ici*/) { struct point p; p.x = p.y = -1; return p; }
Regis
"Miguel" <mickael.i@free.fr> a écrit dans le message de
news:4092ac18$0$425$636a15ce@news.free.fr...
Salut,
voilà, j'aimerais faire une fonction qui me rend un élément de type:
struct point
{
int x;
int y;
}
Att. au point-virgule, };
j'ai un cas de base du type:
if (/*ca dépend, mais ca n'est pas très important ici*/)
return /* point(-1, -1) */;
ce que je voudrais savoir, c'est quoi mettre pour avoir ce point (-1, -1).
J'ai essayé (struct point {-1, -1}); , mais gcc n'a pas apprécié.
Suis-je obligé de créer une variable pour la retourner ou existe-t-il un
moyen?
Si tu souhaites que ca tourne aussi en C90, tu seras obligé de créer une
variable :
if (/*ca dépend, mais ca n'est pas très important ici*/)
{
struct point p;
p.x = p.y = -1;
return p;
}
"Miguel" a écrit dans le message de news:4092ac18$0$425$
Salut,
voilà, j'aimerais faire une fonction qui me rend un élément de type:
struct point { int x; int y; }
Att. au point-virgule, };
j'ai un cas de base du type: if (/*ca dépend, mais ca n'est pas très important ici*/) return /* point(-1, -1) */;
ce que je voudrais savoir, c'est quoi mettre pour avoir ce point (-1, -1). J'ai essayé (struct point {-1, -1}); , mais gcc n'a pas apprécié. Suis-je obligé de créer une variable pour la retourner ou existe-t-il un moyen?
Si tu souhaites que ca tourne aussi en C90, tu seras obligé de créer une variable :
if (/*ca dépend, mais ca n'est pas très important ici*/) { struct point p; p.x = p.y = -1; return p; }
Regis
Emmanuel Delahaye
In 'fr.comp.lang.c', JRD wrote:
{ point p; /* le cast n'est pas indispensable (voire inutile) */ p = (point) fonction();
Par contre, ce qui est indispensable c'est tester le retour de malloc()...
Et puis cacher les pointeurs, c'est moche et confusant... Un vrai programmeur C n'a pas honte d'utiliser des pointeurs.
-- -ed- get my email here: http://marreduspam.com/ad672570 The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', JRD <NOSPAMjerome.drapeau@free.fr> wrote:
{
point p;
/* le cast n'est pas indispensable (voire inutile) */
p = (point) fonction();
Par contre, ce qui est indispensable c'est tester le retour de malloc()...
Et puis cacher les pointeurs, c'est moche et confusant... Un vrai programmeur
C n'a pas honte d'utiliser des pointeurs.
--
-ed- get my email here: http://marreduspam.com/ad672570
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
{ point p; /* le cast n'est pas indispensable (voire inutile) */ p = (point) fonction();
Par contre, ce qui est indispensable c'est tester le retour de malloc()...
Et puis cacher les pointeurs, c'est moche et confusant... Un vrai programmeur C n'a pas honte d'utiliser des pointeurs.
-- -ed- get my email here: http://marreduspam.com/ad672570 The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
JRD
Emmanuel Delahaye wrote:
In 'fr.comp.lang.c', JRD wrote:
{ point p; /* le cast n'est pas indispensable (voire inutile) */ p = (point) fonction();
Bonjour,
Par contre, ce qui est indispensable c'est tester le retour de malloc()...
Effectivement, c'est indispensable. En fait, si je l'avais vraiment écrit pour moi, j'aurais fait comme je fait d'habitude. C'est à dire que pour une structure, j'écris systématiquement une fonction "d'initialisation". Je trouve cela plus propre: on peut définir ce que l'on veut dans la fonction.
Donc, cela aurait donné :
typedef struct _point { int x; int y; } *point;
/* la fonction d'initialisation peut retourner NULL */ point new_point() { point ret; ret = (point)malloc(sizeof(struct _point)); return ret; }
point fonction() { point ret; ret = new_point();
/* Et c'est la que la verification de l'initialisation s'est bien passe */ if ( ret != NULL ) { ret -> x = 2; ret -> y = -3; } return ret; }
Et puis cacher les pointeurs, c'est moche et confusant... Un vrai programmeur C n'a pas honte d'utiliser des pointeurs.
10% des developpeurs sont de vrais programmeurs, 90% des autres le pensent...
JRD. --
http://jerome.drapeau.free.fr La critique est aisée, l'art est difficile.
Emmanuel Delahaye <emdelYOURBRA@noos.fr> wrote:
In 'fr.comp.lang.c', JRD <NOSPAMjerome.drapeau@free.fr> wrote:
{
point p;
/* le cast n'est pas indispensable (voire inutile) */
p = (point) fonction();
Bonjour,
Par contre, ce qui est indispensable c'est tester le retour de malloc()...
Effectivement, c'est indispensable.
En fait, si je l'avais vraiment écrit pour moi, j'aurais fait comme je
fait d'habitude. C'est à dire que pour une structure, j'écris
systématiquement une fonction "d'initialisation". Je trouve cela plus
propre: on peut définir ce que l'on veut dans la fonction.
Donc, cela aurait donné :
typedef struct _point
{
int x;
int y;
} *point;
/* la fonction d'initialisation peut retourner NULL */
point new_point()
{
point ret;
ret = (point)malloc(sizeof(struct _point));
return ret;
}
point fonction()
{
point ret;
ret = new_point();
/* Et c'est la que la verification de l'initialisation s'est bien
passe */
if ( ret != NULL ) {
ret -> x = 2;
ret -> y = -3;
}
return ret;
}
Et puis cacher les pointeurs, c'est moche et confusant... Un vrai programmeur
C n'a pas honte d'utiliser des pointeurs.
10% des developpeurs sont de vrais programmeurs, 90% des autres le
pensent...
JRD.
--
NOSPAMjerome.drapeau@free.fr
http://jerome.drapeau.free.fr
La critique est aisée, l'art est difficile.
{ point p; /* le cast n'est pas indispensable (voire inutile) */ p = (point) fonction();
Bonjour,
Par contre, ce qui est indispensable c'est tester le retour de malloc()...
Effectivement, c'est indispensable. En fait, si je l'avais vraiment écrit pour moi, j'aurais fait comme je fait d'habitude. C'est à dire que pour une structure, j'écris systématiquement une fonction "d'initialisation". Je trouve cela plus propre: on peut définir ce que l'on veut dans la fonction.
Donc, cela aurait donné :
typedef struct _point { int x; int y; } *point;
/* la fonction d'initialisation peut retourner NULL */ point new_point() { point ret; ret = (point)malloc(sizeof(struct _point)); return ret; }
point fonction() { point ret; ret = new_point();
/* Et c'est la que la verification de l'initialisation s'est bien passe */ if ( ret != NULL ) { ret -> x = 2; ret -> y = -3; } return ret; }
Et puis cacher les pointeurs, c'est moche et confusant... Un vrai programmeur C n'a pas honte d'utiliser des pointeurs.
10% des developpeurs sont de vrais programmeurs, 90% des autres le pensent...
JRD. --
http://jerome.drapeau.free.fr La critique est aisée, l'art est difficile.
Emmanuel Delahaye
In 'fr.comp.lang.c', JRD wrote:
En fait, si je l'avais vraiment écrit pour moi, j'aurais fait comme je fait d'habitude. C'est à dire que pour une structure, j'écris systématiquement une fonction "d'initialisation". Je trouve cela plus propre: on peut définir ce que l'on veut dans la fonction.
Donc, cela aurait donné :
typedef struct _point { int x; int y; } *point;
Je n'aime toujours pas que l'on cache les pointeurs.
/* la fonction d'initialisation peut retourner NULL */ point new_point() { point ret; ret = (point)malloc(sizeof(struct _point)); return ret; }
Ca, c'est une fonction de création qui n'initialise rien du tout. Si tu ne fais rien d'autre, une ligne suffit. Le cast est toujours aussi inutile. La taille de l'objet est aussi sizeof *ret. 'ret' est un nom curieux pour un objet; 'this' met tout le monde d'accord...
point fonction() { point ret; ret = new_point();
/* Et c'est la que la verification de l'initialisation s'est bien passe */ if ( ret != NULL ) { ret -> x = 2; ret -> y = -3;
Ca c'est l'initialisation.
} return ret; }
-- -ed- get my email here: http://marreduspam.com/ad672570 The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', JRD <NOSPAMjerome.drapeau@free.fr> wrote:
En fait, si je l'avais vraiment écrit pour moi, j'aurais fait comme je
fait d'habitude. C'est à dire que pour une structure, j'écris
systématiquement une fonction "d'initialisation". Je trouve cela plus
propre: on peut définir ce que l'on veut dans la fonction.
Donc, cela aurait donné :
typedef struct _point
{
int x;
int y;
} *point;
Je n'aime toujours pas que l'on cache les pointeurs.
/* la fonction d'initialisation peut retourner NULL */
point new_point()
{
point ret;
ret = (point)malloc(sizeof(struct _point));
return ret;
}
Ca, c'est une fonction de création qui n'initialise rien du tout. Si tu ne
fais rien d'autre, une ligne suffit. Le cast est toujours aussi inutile. La
taille de l'objet est aussi sizeof *ret. 'ret' est un nom curieux pour un
objet; 'this' met tout le monde d'accord...
point fonction()
{
point ret;
ret = new_point();
/* Et c'est la que la verification de l'initialisation s'est bien
passe */
if ( ret != NULL ) {
ret -> x = 2;
ret -> y = -3;
Ca c'est l'initialisation.
}
return ret;
}
--
-ed- get my email here: http://marreduspam.com/ad672570
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
En fait, si je l'avais vraiment écrit pour moi, j'aurais fait comme je fait d'habitude. C'est à dire que pour une structure, j'écris systématiquement une fonction "d'initialisation". Je trouve cela plus propre: on peut définir ce que l'on veut dans la fonction.
Donc, cela aurait donné :
typedef struct _point { int x; int y; } *point;
Je n'aime toujours pas que l'on cache les pointeurs.
/* la fonction d'initialisation peut retourner NULL */ point new_point() { point ret; ret = (point)malloc(sizeof(struct _point)); return ret; }
Ca, c'est une fonction de création qui n'initialise rien du tout. Si tu ne fais rien d'autre, une ligne suffit. Le cast est toujours aussi inutile. La taille de l'objet est aussi sizeof *ret. 'ret' est un nom curieux pour un objet; 'this' met tout le monde d'accord...
point fonction() { point ret; ret = new_point();
/* Et c'est la que la verification de l'initialisation s'est bien passe */ if ( ret != NULL ) { ret -> x = 2; ret -> y = -3;
Ca c'est l'initialisation.
} return ret; }
-- -ed- get my email here: http://marreduspam.com/ad672570 The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
Marc Boyer
JRD wrote:
La question n'est pas très claire. Il faut allouer de la mémoire pour la structure pour quelle soit mise dans le "tas" (heap), sinon elle (la structure) est définie dans la "pile" (stack) et est donc perdue après la sortie de la fonction.
Non, non, il désire renvoyer une structure (et pas un pointeur sur structure [1]) et elle existera assez longtemps pour être copiée dans la variable du programme appelant.
[1] apres, on peut discuter ce choix de conception. Marc Boyer -- La contractualisation de la recherche, c'est me donner de l'argent pour faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce que je sais faire, je le fais sans moyens...
JRD wrote:
La question n'est pas très claire.
Il faut allouer de la mémoire pour la structure pour quelle soit mise
dans le "tas" (heap), sinon elle (la structure) est définie dans la
"pile" (stack) et est donc perdue après la sortie de la fonction.
Non, non, il désire renvoyer une structure (et pas un pointeur
sur structure [1]) et elle existera assez longtemps pour être
copiée dans la variable du programme appelant.
[1] apres, on peut discuter ce choix de conception.
Marc Boyer
--
La contractualisation de la recherche, c'est me donner de l'argent pour
faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce
que je sais faire, je le fais sans moyens...
La question n'est pas très claire. Il faut allouer de la mémoire pour la structure pour quelle soit mise dans le "tas" (heap), sinon elle (la structure) est définie dans la "pile" (stack) et est donc perdue après la sortie de la fonction.
Non, non, il désire renvoyer une structure (et pas un pointeur sur structure [1]) et elle existera assez longtemps pour être copiée dans la variable du programme appelant.
[1] apres, on peut discuter ce choix de conception. Marc Boyer -- La contractualisation de la recherche, c'est me donner de l'argent pour faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce que je sais faire, je le fais sans moyens...
Marc Boyer
Régis Troadec wrote:
Si tu souhaites que ca tourne aussi en C90, tu seras obligé de créer une variable :
if (/*ca dépend, mais ca n'est pas très important ici*/) { struct point p; p.x = p.y = -1; return p; }
Ou alors (plus simple à mon gout) { [const] struct point p={-1,-1}; return p; }
Marc Boyer -- La contractualisation de la recherche, c'est me donner de l'argent pour faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce que je sais faire, je le fais sans moyens...
Régis Troadec wrote:
Si tu souhaites que ca tourne aussi en C90, tu seras obligé de créer une
variable :
if (/*ca dépend, mais ca n'est pas très important ici*/)
{
struct point p;
p.x = p.y = -1;
return p;
}
Ou alors (plus simple à mon gout)
{
[const] struct point p={-1,-1};
return p;
}
Marc Boyer
--
La contractualisation de la recherche, c'est me donner de l'argent pour
faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce
que je sais faire, je le fais sans moyens...
Si tu souhaites que ca tourne aussi en C90, tu seras obligé de créer une variable :
if (/*ca dépend, mais ca n'est pas très important ici*/) { struct point p; p.x = p.y = -1; return p; }
Ou alors (plus simple à mon gout) { [const] struct point p={-1,-1}; return p; }
Marc Boyer -- La contractualisation de la recherche, c'est me donner de l'argent pour faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce que je sais faire, je le fais sans moyens...
Yves ROMAN
Régis Troadec wrote:
Si tu souhaites que ca tourne aussi en C90, tu seras obligé de créer une variable :
if (/*ca dépend, mais ca n'est pas très important ici*/) { struct point p; p.x = p.y = -1; return p; }
Ou alors (plus simple à mon gout) { [const] struct point p={-1,-1}; return p; }
Voire même :
static const struct point POINT_SPECIAL = {-1,-1} ; if (/*ca dépend, mais ca n'est pas très important ici*/) { return POINT_SPECIAL; }
Régis Troadec wrote:
Si tu souhaites que ca tourne aussi en C90, tu seras obligé de créer une
variable :
if (/*ca dépend, mais ca n'est pas très important ici*/)
{
struct point p;
p.x = p.y = -1;
return p;
}
Ou alors (plus simple à mon gout)
{
[const] struct point p={-1,-1};
return p;
}
Voire même :
static const struct point POINT_SPECIAL = {-1,-1} ;
if (/*ca dépend, mais ca n'est pas très important ici*/)
{
return POINT_SPECIAL;
}