Logo GNT
Actualités Tests & Guides Bons Plans
GTA 6 iPhone 17 Copilot Switch 2 Temu ChatGPT Tesla
OVH Cloud OVH Cloud
Entraide Développement Développement Langage C Passage de structure en paramètre d'une fonction

Passage de structure en paramètre d'une fonction

55 réponses
Avatar
Rémi BERTHOLET
Bonjour,

J'ai un code qui ressemble =E0 cela :

struct MaStructure
{
int x;
int y;
};


void MaFonction(struct MaStructure)
{
...
}


Je peux appeler ma fonction en faisant :
struct MaStructure data =3D {0,0};
MaFonction(data);

Mais je voudrais faire quelque chose comme cela :
MaFonction({0,0});

Existe t'il une syntaxe en C pour le faire ?

Merci
Signaler un problème avec ce contenu

10 réponses

Supprimer
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
1 2 3 4 5
Avatar
Samuel DEVULDER
Marc Espie a écrit :

Je suis toujours pas pour. Je ne vois ce qui interdisait d'ecrire les choses
classiquement, genre

struct S s;

s.a = valeur;
s.b = autre;
...



Ca ne marche pas pour les structures statiques globales.

sam.
Avatar
Antoine Leca
Alexandre Bacquart écrivit :
On 07/26/2010 04:59 PM, Marc Espie wrote:
Par exemple, dans mes messages, je ne met souvent pas d'accents, vieille
habitude de clavier qwerty et flemme d'aller chercher les raccourcis.



Je comprends ça, j'ai aussi une large préférence pour le qwerty en
général, sauf pour écrire dans la langue de Molière...



Je ne vois pas le rapport.

J'écris sur un clavier qwerty, parce que c'est ce que j'ai sous la main.
Quand je dois passer à un clavier azerty, c'est la croix et la bannière,
je vais une foultitude d'erreurs de frappe (en plus de d'habitude,
hein); et si au bout d'une semaine cela va mieux, hop je repasse de
l'autre côté de la frontière et rekapoum...

Par ailleurs, j'écris avec des accents parce que je trouve cela plus
joli, même s'il faut que je presse deux touches (l'une à côté du Ñ ou du
P, puis la voyelle) ; mais pour taper un nombre, je n'ai besoin
d'appuyer que sur une seule touche...

Alors évidemment, je ne suis pas É.-U. ni au R.U., donc sur mon clavier
j'ai les fameuses touches mortes (comme le ^ et le ¨ en France), et je
suis tributaire de l'installation d'un morceau de code adapté à mon
clavier... et bien sûr, tributaire de tous ces programmes «intelligents»
qui « devinent » que parce que je suis sur un clavier espagnol, il faut
me parler en espagnol ; puis qui puisque j'ai changé la langue de
l'interface pour le français, voudrait m'imposer à la place un dessind e
clavier azerty @#$ :-(


Antoine
Avatar
espie
In article <4c4dc0ab$0$17075$,
Samuel DEVULDER wrote:
Marc Espie a écrit :

Je suis toujours pas pour. Je ne vois ce qui interdisait d'ecrire les choses
classiquement, genre

struct S s;

s.a = valeur;
s.b = autre;
...



Ca ne marche pas pour les structures statiques globales.



Et si tu suis vaguement la discussion, et pas juste le dernier message local,
je disais un peu plus haut que ca ne m'aurait pas paru aberrant d'autoriser
ca pour des statiques globales (quitte a restreindre drastiquement le code
autorise). Ca aurait evite d'inventer une nouvelle syntaxe a la
mors-moi-le-noeud.
Avatar
Samuel DEVULDER
Marc Espie a écrit :
In article <4c4dc0ab$0$17075$,
Samuel DEVULDER wrote:
Marc Espie a écrit :

Je suis toujours pas pour. Je ne vois ce qui interdisait d'ecrire les choses
classiquement, genre

struct S s;

s.a = valeur;
s.b = autre;
...


Ca ne marche pas pour les structures statiques globales.



Et si tu suis vaguement la discussion,



Je le fais, mais je trouve que c'est devenu du grand n'importe quoi(tm)
dans la digression par rapport au problème d'origine. Il faudrait
peut-etre changer le titre quand ca part dans les histoires
anti-microsofteries, anti/pro-glibc, et je ne sais quelle paroisse encore.

et pas juste le dernier message local,





Ecoutes. Je réponds à ton dernier message sur le sujet des
l'initialisations. Après si c'est planqué dans les batailles de standard
oui je suis probablement passé à coté.

je disais un peu plus haut que ca ne m'aurait pas paru aberrant d'autoriser
ca pour des statiques globales (quitte a restreindre drastiquement le code
autorise). Ca aurait evite d'inventer une nouvelle syntaxe a la
mors-moi-le-noeud.



Ok c'est avant la digression.. je reprends le fil à son origine et ne
trouve qu'un seul message:

<<C'est un des trucs dont je ne vois pas trop l'interet. Ca ne fait que
rajouter de la syntaxe pas tres utile a un langage qui est deja
bloated.>> ?

==> Pas de références aux statiques globales ici.

Plus loin: <<Je ne suis pas non plus fan des initialiseurs a la con....
ca aurait bien plus simple d'autoriser les operateurs d'affectation
classiques un peu partout, y compris pour fixer des valeurs initiales de
variables en dehors d'une fonction, plutot que d'inventer encore un bout
de syntaxe bizarroide.>>

==> Pas de références aux statiques globales non plus.

Donc soit tu as rêvé avoir écrit au sujet des vars statiques globales,
soit tu dois avoir écrit cela de façon moins lisible, limite subliminale.

Est-ce que quand tu parles d'<<operateurs d'affectations en dehors des
fonctions>> tu veux parler du cas de l'init des vars statiques? Moi j'ai
pas du tout compris cela. Alors franchement au lieu de prendre tout le
monde de haut, est-ce que tu ne pouvais pas parler clairement avec un
exemple parlant de ce que tu veux dire, au moins pour que les profanes
puisse profiter de ton éclairage sur le sujet, plutôt que de partir à la
croisade anti-microsoft (je sais ca a du succès, mais ca n'est pas
exactement le sujet).

Du coup ca m'intéresse d'avoir un exemple sur la façon de faire une
chose pareille avec des opérateurs flottants un peu partout dans le
code. Par exemple comment initialiserais tu les données suivantes:

struct toto {
int a;
int b;
} tab[] = {{.a=1}, {.b=2}, {.b=3, .a=4}};

Est-ce que ca revient à avoir une section "static {}" à la java qui
serait appelée par le runtime pour exécuter du code avant que toute
autre fonction ne soit exécutée, par exemple avant d'entrer dans le main():

struct toto tab[3]; // oui obligé de préciser
// la taille dans ce cas
static {tab[0].a = 1; tab[1].b = 2; ... }

Y aurait il une seule section statique globale, une par module *.obj,
plusieurs, un par variable globale? Qu'aurait-on le droit d'écrire dans
ces sections static? En particulier, est-ce que dans une section static
on peut référencer des vars globales venant d'un autre section static ou
d'un autre module ".obj/.o"? comment ca se passe en cas de dépendance
circulaire lors des initialisations?

Pas mal de questions intéressantes je trouve.

sam.
Avatar
espie
In article <4c4dd487$0$24800$,
Samuel DEVULDER wrote:
Marc Espie a écrit :
Plus loin: <<Je ne suis pas non plus fan des initialiseurs a la con....
ca aurait bien plus simple d'autoriser les operateurs d'affectation
classiques un peu partout, y compris pour fixer des valeurs initiales de
variables en dehors d'une fonction, plutot que d'inventer encore un bout
de syntaxe bizarroide.>>

==> Pas de références aux statiques globales non plus.

Donc soit tu as rêvé avoir écrit au sujet des vars statiques globales,
soit tu dois avoir écrit cela de façon moins lisible, limite subliminale.

Est-ce que quand tu parles d'<<operateurs d'affectations en dehors des
fonctions>> tu veux parler du cas de l'init des vars statiques? Moi j'ai
pas du tout compris cela. Alors franchement au lieu de prendre tout le
monde de haut, est-ce que tu ne pouvais pas parler clairement avec un
exemple parlant de ce que tu veux dire, au moins pour que les profanes
puisse profiter de ton éclairage sur le sujet, plutôt que de partir à la
croisade anti-microsoft (je sais ca a du succès, mais ca n'est pas
exactement le sujet).



Ben evidemment que ca s'applique aux statiques globales.

Operateur d'affectation, tu vois ce que c'est quand meme... non ?
(hint: c'est la traduction francaise habituelle "d'assignment operator",
qui est le terme utilise classiquement dans les textes normatifs)

Et fixer des valeurs initiales de variables, meme en dehors d'une
fonction ? c'est pas clair peut-etre ?

Evidemment, si tu veux absolument les mots-cles "statiques globales", non,
ils n'y sont pas.

Je parle juste d'initialiser une variable en dehors d'une fonction (c'est
donc forcement une variable globale, hein...), en utilisant un operateur
d'affectation (assignment operator) au lieu d'etre contraint a utiliser
un initializer.

Apres, si utiliser les memes termes que la norme, c'est prendre les gens
de haut, alors ouais, je prend les gens de haut...
Avatar
Samuel DEVULDER
Marc Espie a écrit :

Operateur d'affectation, tu vois ce que c'est quand meme... non ?



:) Tu cherches à entrer en conflit (Microsoft n'est pas suffisant? ;) ).
Je te laisse à ton délire.

<couic le reste sans intérêt qui ne répond même pas aux questions posées
quant au concept proposé. Doit-on en conclure que ce concept est creux?>

sam.
Avatar
espie
In article <4c4de1d4$0$14950$,
Samuel DEVULDER wrote:
<couic le reste sans intérêt qui ne répond même pas aux questions posées
quant au concept proposé. Doit-on en conclure que ce concept est creux?>



Evidemment, si tu debranches ton cerveau, tu ne risques pas de voir les
reponses qu'on te donne.

Putain, mais merde, je fais l'effort d'expliciter ce que je raconte, tu
pourrais au moins faire l'effort d'essayer de lire et de comprendre.

Donc question de base: vois-tu la difference entre initializer et
assignment operator dans la norme ?
Avatar
Samuel DEVULDER
Marc Espie a écrit :
In article <4c4de1d4$0$14950$,
Samuel DEVULDER wrote:
<couic le reste sans intérêt qui ne répond même pas aux questions posées
quant au concept proposé. Doit-on en conclure que ce concept est creux?>



Evidemment, si tu debranches ton cerveau, tu ne risques pas de voir les
reponses qu'on te donne.



Du calme!

Putain, mais merde, je fais l'effort d'expliciter ce que je raconte, tu
pourrais au moins faire l'effort d'essayer de lire et de comprendre.



Re calmos! J'ai posé des questions avec exemple précis. Et tu n'y
réponds pas. Est-ce que j'emporte pour autant?

Donc question de base: vois-tu la difference entre initializer et
assignment operator dans la norme ?



Un exemple vaut parfois mieux qu'un long discours avec plein mot clefs
fort savants qui plane à 30000pieds de haut.

Je me re-cite, ca ne se fait pas mais tu as zappé la seule partie utile
de mon message:
======8<============================================================ Du coup ca m'intéresse d'avoir un exemple sur la façon de faire une
chose pareille avec des opérateurs flottants un peu partout dans le
code. Par exemple comment initialiserais tu les données suivantes:

struct toto {
int a;
int b;
} tab[] = {{.a=1}, {.b=2}, {.b=3, .a=4}};

Est-ce que ca revient à avoir une section "static {}" à la java qui
serait appelée par le runtime pour exécuter du code avant que toute
autre fonction ne soit exécutée, par exemple avant d'entrer dans le main():

struct toto tab[3]; // oui obligé de préciser
// la taille dans ce cas
static {tab[0].a = 1; tab[1].b = 2; ... }
======8<============================================================
Si ca n'est pas cela, pourrais tu expliciter sur le même exemple (ras du
sol, ok, mais bon c'est pour fixer les idées) comment tu ferais
l'initialisation de tab, stp?

sam.
Avatar
espie
In article <4c4de6bc$0$10744$,
Samuel DEVULDER wrote:
struct toto {
int a;
int b;
} tab[] = {{.a=1}, {.b=2}, {.b=3, .a=4}};

Est-ce que ca revient à avoir une section "static {}" à la java qui
serait appelée par le runtime pour exécuter du code avant que toute
autre fonction ne soit exécutée, par exemple avant d'entrer dans le main():

struct toto tab[3]; // oui obligé de préciser
// la taille dans ce cas
static {tab[0].a = 1; tab[1].b = 2; ... }



pas besoin de static ni de taille, a mon avis.

struct toto tab[];

tab[0].a = 1;
tab[1].b = 2;


Le compilo doit juste reperer que ces affectations servent a initialiser une
variable (c'est pas tres dur, tu peux imposer des contraintes, comme de ne
pas avoir d'autre fonction entre la variable et les affectations, plus la
contrainte evidente que tu n'autorise les affectations "libres" que pour
des variables globales), et se dire que si la variable n'a pas de taille, c'est
que cette taille doit se deduire des affectations qui suivent.

C'est pas vraiment plus de boulot (plutot moins, en fait) qu'un nombre
important d'autres modifs permises par la norme. Et ca a le gros avantage
de rester tres proche du C classique.

La seule objection, c'est que ca rend un peu plus floue la distinction entre
initialisation et affectation. Et il faut permettre aussi:

const struct toto tab[];

tab[0].a = 1;
tab[1].b = 2;


mais la distinction est deja vachement floue. et c'est pas plus casse-gueule,
a mon avis, que

void f()
{
static int a = 5;
...
}
Avatar
Samuel DEVULDER
Marc Espie a écrit :
In article <4c4de6bc$0$10744$,
Samuel DEVULDER wrote:
struct toto {
int a;
int b;
} tab[] = {{.a=1}, {.b=2}, {.b=3, .a=4}};

Est-ce que ca revient à avoir une section "static {}" à la java qui
serait appelée par le runtime pour exécuter du code avant que toute
autre fonction ne soit exécutée, par exemple avant d'entrer dans le main():

struct toto tab[3]; // oui obligé de préciser
// la taille dans ce cas
static {tab[0].a = 1; tab[1].b = 2; ... }



pas besoin de static ni de taille, a mon avis.

struct toto tab[];

tab[0].a = 1;
tab[1].b = 2;




Merci pour la réponse étoffée d'exemples. C'est pile ce que je
souhaitais: je comprends mieux sur un exemple que sur des trucs
abstraits. Et je ne dois pas être le seul, surtout en fin de journée.

De toute évidence, cette écriture est moins compacte (répétition de tab)
que celle avec ".a=1", mais pas illisible pour autant, c'est vrai.


Le compilo doit juste reperer que ces affectations servent a initialiser une
variable (c'est pas tres dur, tu peux imposer des contraintes, comme de ne
pas avoir d'autre fonction entre la variable et les affectations, plus la
contrainte evidente que tu n'autorise les affectations "libres" que pour



Il doit aussi s'assurer que les indices sont des constantes et qu'on
initialise pas deux fois la même chose (tab[0].a par exemple).

des variables globales), et se dire que si la variable n'a pas de taille, c'est
que cette taille doit se deduire des affectations qui suivent.



Est-ce qu'on pourrait pousser le luxe jusqu'à avoir un int c[] dans toto
et que:

tab[2].c[3] = 5;

soit accepté? La détermination de la taille de tab, ainsi que celle de c
nécessiterait de maintenir pas mal d'info sur les indices max des
sous-elements de la structure en cours de route. Mais du coup on
pourrait carrément avoir cela pour les tableaux multi dimensionnels?

int tab[][];
tab[3][4] = 2;

Ca serait pas mal pour étendre les matrices creuses sans avoir à ajouter
des {} vides pour les lignes insérées.

sam.
1 2 3 4 5