Coucou, encore moi et mes problèmes de débutant

Je précise que je programme en C sous PODS

Le problème d'aujourd'hui est le suivant:

Dans un fichier, je déclare le tableau de constantes suivants,

static const tDouble colours_rgb[32][3] SECTION_CONST;
static const tDouble colours_rgb[32][3] =
{
{ 0.5, 0.5, 0.5 }, { 0.5, 0.5, 0.5 },{ 0.0, 1.0, 0.5 }, { 1.0, 1.0, 0.5 },
{ 0.0, 0.0, 0.5 }, { 1.0, 0.0, 0.5 },{ 0.0, 0.5, 0.5 }, { 1.0, 0.5, 0.5 },
{ 1.0, 0.0, 0.5 }, { 1.0, 1.0, 0.5 },{ 1.0, 1.0, 0.0 }, { 1.0, 1.0, 1.0 },
{ 1.0, 0.0, 0.0 }, { 1.0, 0.0, 1.0 },{ 1.0, 0.5, 0.0 }, { 1.0, 0.5, 1.0 },
{ 0.0, 0.0, 0.5 }, { 0.0, 1.0, 0.5 },{ 0.0, 1.0, 0.0 }, { 0.0, 1.0, 1.0 },
{ 0.0, 0.0, 0.0 }, { 0.0, 0.0, 1.0 },{ 0.0, 0.5, 0.0 }, { 0.0, 0.5, 1.0 },
{ 0.5, 0.0, 0.5 }, { 0.5, 1.0, 0.5 },{ 0.5, 1.0, 0.0 }, { 0.5, 1.0, 1.0 },
{ 0.5, 0.0, 0.0 }, { 0.5, 0.0, 1.0 },{ 0.5, 0.5, 0.0 }, { 0.5, 0.5, 1.0 }
};


Plus loin dans le code, je désire anfin utiliser ces constantes dans une fonction qui ne se trouve pas dans la même section.

static tVoid video_set_palette(tVoid) SECTION_CPC;
...
tVoid video_set_palette(tVoid)
{
...
red = (tULong)(colours_rgb[n][0] * (CPC->scr_intensity / 10.0) * 255);
...
}
Le problème est que colours_rgb ne pointe absolument pas sur le tableau défini au-dessus.

Je pense que cela est normal, encore un problème d'accès à +/- 32k. Mais comment pallier cette abération ?

J'espère que j'ai été assez clair !!

Merci beaucoup...Je continue à chercher une solution.

J'ai eut le même soucis que toi,
j'ai viré le "static const", et ça a marché.

Tu peux aussi essayer seulemenent "static" ou seulement "const" si tu veux garder un de ces mots clefs.

Merci, je vais essayer

Comme je n'ai pas envie de surcharger la taille des variables globales, je tiens à garder le "const".

Toutefois, en ne retirant que le "static", c'est pareil qu'avant.

Par contre, l'accès fonctionne si je ne place pas le tableau dans une autre section !!!

... Et je continue à chercher ...

Si je me souviens bien,
le mot clef "static" sur une variable globale ne sert qu'à indiquer au compilateur qu'il ne doit pas exporter le nom,

le mot clef "const" indique juste qu'on ne peut pas modifier le contenu.

Sauf si la doc de GCC indique le contraire, mettre ou ne pas mettre ces mots clefs ne change pas l'endroit ou sont stockées ces données ( c'est une supposition que je fais, je n'ai pas lu la doc ).

J'aurais le même avis que Lu1u... Par ailleurs, il me semblait que les variables globales ne pouvaient se trouver que dans le segment "principal"...

Bonjour,

Je ne suis un un 'C user' auquel je ne connais rien, mais il y a une solution que j'utilise sous PP et qui fonctionne en multisegment :

Il s'agit d'injecter tes constantes directement dans ton code, en faisant précéder tout cela d'un jump inconditionnel vers la fin de ton tableau : c'est la ruse utilisée pour créer les 'dispatch tables' dans les libraries voir : http://www.isaac.cs.berkeley.edu/pilot/shlib.html pour le 'C' et la théorie.

Pour ce qui des exemples en Pascal et des applications pour le stockage des constantes, voir PPMath (32 bits real) ou 64 bits (mode 68k) sur le site de PPCompiler, il y a des sauts courts, long, en mode 68k et en mode armlet.

Attention toutefois si tu utilises ce truc en mode 'armlet' avec les éternels pb d'alignement et d'adresses.

Voili, voilou.

static et const servent à restreindre l'accès aux données:

- static: accès impossible en dehors du fichier .c
- const: lecture seule.

=> C'est très utile dans le cadre de projets multi-développeurs ( pour éviter que n'importe qui vienne faire n'importe quoi dans le module dont tu es responsable ). Si comme je l'imagine, tu es seul sur ton programme, il te suffira d'un peu "d'auto-discipline" et de rigueur pour remplacer avantageusement ces mots clés.

=> J'ai de toutes façons tendance à éviter les variables globales autant que possible, même hors de PalmOS, as-tu envisagé la possibilité de stocker tes valeurs ailleurs ? ( une database, le retour d'une fonction...)

=> Je ne connais pas suffisament GCC pour savoir si const et static aurait une influence sur la génération ( peut-être l'optimisation ) du code.

Je suis tout à fait d'accord avec toi, mais je suis en train de porter un code déjà écris, enfin d'essayer

Donc, j'essais de restreindre les accès afin de mieux comprendre les comportements.
Et comme il y a beaucoup de globales, je pars du principe qu'elles sont automatiquement "privées", donc static...

Pour les constantes, il s'agit des lourdes tables de constantes qu'il vaux mieux garder prés de là où elles vont être utilisées. Mais tu as raison, pour une optimisation future, je les passerai surement en ressource ou base de données !!

L'inconvénient du retour d'une fonction est la lenteur de l'accès à la variable. Comme en embarqué, rien ne vaut un bon pointeur des années casté à gogo...