Discussion :

[davkick]

Bonjour,

une petite question concernant une variable globale. Est-il mieux de faire :

Code :

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

1
2
3
 
// ds PalIntern.h
extern volatile ST_HARD_REG *st_hard_reg;

+

Code :

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

1
2
3
 
// ds main.c
volatile ST_HARD_REG *st_hard_reg=(ST_HARD_REG *)0xFFC00000;

ou

Code :

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

1
2
3
 
// ds PalIntern.h
static volatile ST_HARD_REG *st_hard_reg=(ST_HARD_REG *)0xFFC00000;

Evidemment PalIntern.h est inclut dans les fichiers ou j'ai besoin de st_hard_reg.

Merci d'avance.

[Drahl]

Une variable globale ce déclare dans un fichier d'en-téte et s'initialise dans le fichier C !! donc la premiére solution

Code :

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

1
2
3
4
// ds PalIntern.h 
extern volatile ST_HARD_REG *st_hard_reg; 
// ds main.c 
volatile ST_HARD_REG *st_hard_reg=(ST_HARD_REG *)0xFFC00000;

[Trap D]

La premiere méthode est la bonne, puisque avec la deuxième méthode, st_hard_reg est déclarée static et initialisée dans tous les fichiers où le .h est inclus.
D'autre part, ta question relève plutôt du C++, pas du C.

[davkick]

Merci pour vos réponses,

mais juste une précision pourTrap D, je ne vois pas pourquoi avec la deuxième méthode st_hard_reg n'est pas initialise a chaque inclusion du fichier vu qu'en début du .h j'ai ceci :

Code :

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

1
2
3
 
#ifndef _PAL_INTERN_H
#define _PAL_INTERN_H

Ensuite deuxième précision, je suis bien en train d'écrire du C vu que je travaille sur microcontroleru, de plus je ne vois pas ou se trouve la référence a du C++ dans mon code.

Merci.

[Trap D]

mais juste une precision pourTrap D, je ne vois pas pkoi avec la deuxieme methode st_hard_reg n'est pas initialise a chaque inclusion du fichier vu qu'en debut du .h j'ai ca :

Code :

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

1
2
3
 
#ifndef _PAL_INTERN_H
#define _PAL_INTERN_H

Si justement,

Code :

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

1
2
// ds PalIntern.h
static volatile ST_HARD_REG *st_hard_reg=(ST_HARD_REG *)0xFFC00000;

dans chaque .c où sera inclus le .h il y aura bien déclaration et définition de st_hard_reg.
D'autre part, sur ma doc (MSDN) volatile est un modifieur C++. (je ne le connais pas en tant que mot-cle C, qu'elle en est sa signification ?).

[Trap D]

OK, je viens de trouver sur Google.
j'aurais appris deux choses aujourd'hui
ce que veut dire 'volatile'
bien lire les docs (ce n'est pas très clair sur MSDN).

[Drahl]

Si volatile et du C ANSI et il permet d'éviter les simplification que pourrais faire le compilateur, c'est à dire par exemple :

Code :

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

1
2
3
4
5
6
7
8
int fonction ()
{
int var;
int toto;
var = 10;
toto = var; //le compilateur vas supprimer cette ligne pcq il la concidére obsolette et ne vas rien faire sur toto
return (var);
}

alors que :

Code :

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

1
2
3
4
5
6
7
8
int fonction ()
{
int var;
volatile int toto;
var = 10;
toto = var; //par contre la il vas quand même exécuter la ligne
return (var);
}

[DavG]

mais juste une precision pourTrap D, je ne vois pas pkoi avec la deuxieme methode st_hard_reg n'est pas initialise a chaque inclusion du fichier vu qu'en debut du .h j'ai ca :

En effet, avec la deuxième méthode tu auras une variable locale à chaque fichier, mais c'est pas propre et ça ne sert à rien de la mettre dans le .h si l'utilisation est locale !

Si volatile et du C ANSI et il permet d'éviter les simplification que pourrais faire le compilateur, c'est à dire par exemple :

En fait volatile ce n'est pas ça le but : en la déclarant volatile, à chaque utilisation de la variable sa valeur sera lue en mémoire (pas de registre utilisé), ce qui permet à une variable partagée (thread, interruption, ..) de ne jamais être corrompue, mais est beaucoup plus lent en accès !!

[Trap D]

Vu ceci

6) Variables volatiles

A l'inverse de const, les variables volatiles sont utilisées dans le cas où la valeur d'une variable peut à tout moment être changée à l'extérieur du programme exécutant. On retrouve ce genre d'utilisation dans les programmes multi-threads ou pour accéder aux registres de la machine. Déclarer une variable volatile indique au compilateur qu'aucune optimisation ne doit être appliquée à cette variable. Le contenu de la variable sera lu chaque fois que l'on accédera à celle-ci (même si l'on vient de s'en servir).

[davkick]

Merci a tous pour vos precisions,

je vais donc choisir la premiere solution.

[Emmanuel Delahaye]

une petite question concernant une variable globale. Est-il mieux de faire :

Code :

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

1
2
3
 
// ds PalIntern.h
extern volatile ST_HARD_REG *st_hard_reg;

+

Code :

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

1
2
3
 
// ds main.c
volatile ST_HARD_REG *st_hard_reg=(ST_HARD_REG *)0xFFC00000;

Oui, à condition d'inclure "PalIntern.h" dans main.c

ou

Code :

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

1
2
3
 
// ds PalIntern.h
static volatile ST_HARD_REG *st_hard_reg=(ST_HARD_REG *)0xFFC00000;

Non (multiplication inutile d'une variable).

[Emmanuel Delahaye]

D'autre part, ta question relève plutôt du C++, pas du C.

Meuh ? Pourquoi à cause des // ?

[Emmanuel Delahaye]

mais juste une precision pourTrap D, je ne vois pas pkoi avec la deuxieme methode st_hard_reg n'est pas initialise a chaque inclusion du fichier vu qu'en debut du .h j'ai ca :

Code :

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

1
2
3
 
#ifndef _PAL_INTERN_H
#define _PAL_INTERN_H

Ceci protège des inclusions multiples, pas des multiples inclusions!

D'autre part, tu empiètes sauvagement sur le domaine des noms réservés à l'implantation. Pas portable.

http://emmanuel-delahaye.developpez....nom_underscore

Je recommande

Code :

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

1
2
3
 
#ifndef H_PAL_INTERN
#define H_PAL_INTERN

http://emmanuel-delahaye.developpez....ganiser_source

[Emmanuel Delahaye]

D'autre part, sur ma doc (MSDN) volatile est un modifieur C++. (je ne le connais pas en tant que mot-cle C, qu'elle en est sa signification ?).

volatile est un mot clé du C qui signifie que l'objet peut être modifié extérieurement à l'unité d'exécution.

ISO/IEC 9899:1999 (E) ©ISO/IEC
completes the specification of the new type.
Forward references: declarators (6.7.5), array declarators (6.7.5.2), type definitions
(6.7.7).
6.7.3 Type qualifiers
Syntax
1 type-qualifier:
const
restrict
volatile
Constraints
2 Types other than pointer types derived from object or incomplete types shall not be
restrict-qualified.
Semantics
3 The properties associated with qualified types are meaningful only for expressions that
are lvalues.112)
4 If the same qualifier appears more than once in the same specifier-qualifier-list, either
directly or via one or more typedefs, the behavior is the same as if it appeared only
once.
5 If an attempt is made to modify an object defined with a const-qualified type through use
of an lvalue with non-const-qualified type, the behavior is undefined. If an attempt is
made to refer to an object defined with a volatile-qualified type through use of an lvalue
with non-volatile-qualified type, the behavior is undefined.113)
6 An object that has volatile-qualified type may be modified in ways unknown to the
implementation or have other unknown side effects. Therefore any expression referring
to such an object shall be evaluated strictly according to the rules of the abstract machine,
as described in 5.1.2.3. Furthermore, at every sequence point the value last stored in the
object shall agree with that prescribed by the abstract machine, except as modified by theunknown factors mentioned previously.114) What constitutes an access to an object that
has volatile-qualified type is implementation-defined.
7 An object that is accessed through a restrict-qualified pointer has a special association
with that pointer. This association, defined in 6.7.3.1 below, requires that all accesses to
that object use, directly or indirectly, the value of that particular pointer.115) The intended
use of the restrict qualifier (like the register storage class) is to promote
optimization, and deleting all instances of the qualifier from all preprocessing translation
units composing a conforming program does not change its meaning (i.e., observable
behavior).
8 If the specification of an array type includes any type qualifiers, the element type is soqualified,
not the array type. If the specification of a function type includes any type
qualifiers, the behavior is undefined.116)
9 For two qualified types to be compatible, both shall have the identically qualified version
of a compatible type; the order of type qualifiers within a list of specifiers or qualifiers
does not affect the specified type.
10 EXAMPLE 1 An object declared
extern const volatile int real_time_clock;
may be modifiable by hardware, but cannot be assigned to, incremented, or decremented.
11 EXAMPLE 2 The following declarations and expressions illustrate the behavior when type qualifiers
modify an aggregate type:
const struct s { int mem; } cs = { 1 };
struct s ncs; // the object ncs is modifiable
typedef int A[2][3];
const A a = {{4, 5, 6}, {7, 8, 9}}; // array of array of const int
int *pi;
const int *pci;
ncs = cs; // valid
cs = ncs; // violates modifiable lvalue constraint for =
pi = &ncs.mem; // valid
pi = &cs.mem; // violates type constraints for =
pci = &cs.mem; // valid
pi = a[0]; // invalid: a[0] has type ‘‘const int *’’
---------------------
112) The implementation may place a const object that is not volatile in a read-only region of
storage. Moreover, the implementation need not allocate storage for such an object if its address is
never used.
113) This applies to those objects that behave as if they were defined with qualified types, even if they are
never actually defined as objects in the program (such as an object at a memory-mapped input/output
address).114) A volatile declaration may be used to describe an object corresponding to a memory-mapped
input/output port or an object accessed by an asynchronously interrupting function. Actions on
objects so declared shall not be ‘‘optimized out’’ by an implementation or reordered except as
permitted by the rules for evaluating expressions.
115) For example, a statement that assigns a value returned by malloc to a single pointer establishes this
association between the allocated object and the pointer.
116) Both of these can occur through the use of typedefs.