variables partagées - Page 1

Comment déclare-t-on une variable pour qu'elle soit partagée par toutes les fonctions?

Tu veux surement parler de variables globales, dans ce cas, il faut les délarer au début du prog en dehors de toute fonction.
Mais tu n'es pas obligé d'avoir des variables globales pour pouvoir les utiliser dans toutes les fonctions, il suffit simplement de passer l'adresse de ta variable en argument à la fonction voulue.

C'est justement ce que je veux eviter de faire.

Par contre j'ai essayé de déclarer les variables qui m'interessent en dehors de toute fonction, ce sont des écran virtuels, et ça marche pas.

J'ai mis aprés le #include "tigcclib.h"
void *ecvi1=malloc(3840),*ecvi2=malloc(3840),*ecvi3=malloc(3840),*ecvi4=malloc(3840);

Alors pourquoi ça marche pas si c'est ça que je dois faire.

malloc est une fonction: a utiliser seulement dans une fonction...!
il suffit juste de déclarer tes pointeurs en global (juste apres #include "tigcclib.h"):
void *ecvi1=NULL;
void *ecvi2=NULL;
void *ecvi3=NULL;
void *ecvi4=NULL;

puis dans _main:

ecvi1=malloc(3840);
ecvi2=malloc(3840);
ecvi3=malloc(3840);
ecvi4=malloc(3840);


ps: merci jackiechan91 pr l'erreur (post #6)

faites attention aux var globales quand même.

pourquoi

nhl a écrit :
malloc est une fonction: a utiliser seulement dans une fonction...!
il suffit juste de déclarer tes pointeurs en global (juste apres #include "tigcclib.h"):
void *ecvi1=NULL;

puis dans _main:
*ecvi1=malloc(3840);

Plutôt ecvi1=malloc(3840);

Pim 89
a écrit : faites attention aux var globales quand même.

Pourquoi ?

moi j'utilise void *ecvi1 malloc(3840) et sa marche nickel

Évidemment, si tu l'initialises en même temps que tu le déclares, tu peux faire ça : void *ecvi1=malloc(3840);
Mais si tu le déclares en dehors de toute fonction (comme var globale), tu ne peux pas l'initialiser avec malloc, donc dans main (ou une autre fonction), tu dois mettre ça : ecvi1=malloc(3840);

ben parce que ça prend bcp de place !!!!

C'est juste pour ça ??
M'enfin, si tu déclares juste des pointeurs vers des écrans virtuels ou d'autres petit trucs, ça prend pas trop de place...

c pas très "propre" les variables globales...
(en tout cas, mon prof de C++ ne supporte pas ça !)
(et j'aime pas trop non plus... mais chacun ses gouts )

Tu n'en utilises presque pas ?
Moi, je trouve ça pratique...Ça évite d'avoir des fonctions avec plein d'arguments.
Pourquoi c'est pas "propre" ?

un var globale est accessible de partout... mais elle peut être maskée par des vars locales...
et la rendre modifiable de partout (même de où on ne veut pas qu'elle soit modifiée !) peut permettre des conneries...

dans KII, je n'ai pas une seule variable gloable
(j'en avait deux dans K)
(sans compter les sprites, qui eux, sont en global)

Dans un prog qui touche pas mal à la VAT par exemple, il faut sans arret utiliser un tableau de 18 elements pour convertir les noms de fichiers. Bah dans ce cas il vaut mieux utiliser un tableau en global parceque si tu t'amuse à le faire passer en argument partout t pas sorti !

Enfin peut-être qu'il existe une autre méthode, ça me simplifierait bien la tâche d'ailleurs

ben un pointeur vers un tableau.

moi non plus j'aime pas trop, j'en utilise très peu.

ben un pointeur vers un tableau
> C malin ça

Mhh... Y a un truc que je ne comprends pas : quand je compile mon prog avec des vars globales, il fait 5089 octets, si je vire qq vars globales que je n'utilise que dans une seule fonction et que je les redéclare de façon locale, mon prog fait 5161 octets...
Je précise que ces vars sont des tableaux que j'initialise en moment que je les déclare.

Kevin ??????

vous voulez que je compte les vars globales ds seiken ?

92 en comptant les dlg, sans compter les sprites, et encore c'etait pire avant mais ça va changer

jackiechan91 a écrit :
Mhh... Y a un truc que je ne comprends pas : quand je compile mon prog avec des vars globales, il fait 5089 octets, si je vire qq vars globales que je n'utilise que dans une seule fonction et que je les redéclare de façon locale, mon prog fait 5161 octets... Je précise que ces vars sont des tableaux que j'initialise en moment que je les déclare.

C'est normal. Si tu mets un tableau constant en global, il est dans le programme et sera utilisé directement là-dedans. Si tu le mets en local, il sera présent dans le programme comme initialisateur et recopié sur la pile avant utilisation. Donc il y a la recopie sur la pile en plus.

'tain comme la taille augmente quand même ! vaut mieux quoi alors, global ou local ?

c'est vrai que parfois on se prend un peu la tête avec 2000 pointeurs de tableau , buffer ...

global powa !!! faites comme moi

de toute facon, on a forcement (en programmation graphique) des 2 (sprites, tableaux de niveaux,...) mais c vrai que c chiant a force d'en avoir de trop !

pis c moins beau dans le source

en gros, pr les variables (au sens réel de variables), mieux vaut du local,
et pour les données du style psrites, du gobal... ou alors, pr éviter la recopie sur la pile, des variables locales déclarées en static (ça, je penses que c le plus propre, non ?)

Sinon, juste pr être sûr, les variables globales, c plus rapides que les locales, non, vu qu'on bosse avec des adresses absolues et non relatives par rapport au pointeur de pile ?

Manque de bol c'est l'inverse

les locales sont plus rapides que les globales ???

Vi, pour l'écriture l'adressage x(an) est plus rapide et demande moins de place que l'adressage label, par contre en lecture les deux sont équivalents car label devient relatif au PC.

OK. merci.
donc, en gros, mieux vaut utiliser des locales