EN

pcosmos.ca

l'univers de Philippe Choquette

Types de données

PCASTL : Types de données

Types de base du C
Chaîne de caractères
Tableau
Liste
Objet
Pointeur vers un noeud
Pointeur vers une structure FILE
Pointeur vers une fpos_t
Mémoire brute
Octet
Adresse de mémoire
Pointeur vers les types ci-haut.

Pour afficher le type d'une expression, appeler gettype.

Types de base du C

char
signed char
unsigned char
short
short int
signed short
signed short int
unsigned short
unsigned short int
int
signed int
unsigned
unsigned int
long
long int
signed long
signed long int
unsigned long
unsigned long int
long long
long long int
signed long long
signed long long int
unsigned long long
unsigned long long int
float
double
long double

Pour de l'infomation détaillée à propos de ces types, voir Wikipedia.

Les nombres dans un arbre syntaxique du PCASTL sont représentés comme des double du C. Lorsqu'entrés en notation hexadécimale, ils sont reçus comme des entiers signés avant d'être castés vers double. La notation hexadécimale doit commencer avec "0x". Quand "castés" et stockés dans une variable ou affichés, les nombres peuvent avoir n'importe quel des types de base du C.

> 0xA3
        163
> 0xF0000000
        -268435456
> 4.0
        4
> a = (char)64
        @
> gettype(a)
        "char"
> a = (int)3.1416
        3
> gettype(a)
        "int"
Chaîne de caractères

Les chaînes de caractères en PCASTL sont des tableaux de char du C alloués dynamiquement. Quand vous appelez la fonction length, vous recevez la longueur de la mémoire allouée. Pour recevoir le nombre de caractères avant le caractère nul de la fin, appeler strlen.

Pour obtenir un caractère dans une chaîne de caractères à un index donné, vous pouvez utiliser un indice. Le premier index est zéro.

> a = "hello"
        "hello"
> b = a[1]
        e
> gettype(b)
        "char"
> "hello"[3]
        l

Dans une chaîne de caractères, une séquence échappatoire indique un caractère spécial. Les séquences échappatoires commencent avec un caractère barre oblique inverse (\).

Séquence Nom
\a Alerte (sonnerie)
\b Espace arrière
\f Présentation de page suivante
\n Nouvelle ligne
\r Retour de chariot
\t Tabulation horizontale
\v Tabulation verticale
\? Point d'interrogation littéral
\' Apostrophe
\" Guillemet
\\ Barre oblique inverse
\ddd Caractère ASCII en notation octale
\xdd Caractère ASCII en notation hexadécimale
\0 Caractère nul

Notez que pour les caractères notés en hexadécimal, l'interpréteur ignore tous les zéros en tête. Il établit la fin du caractère échappatoire spécifié en hexadécimal quand il rencontre soit le premier caractère non hexadécimal ou plus de deux caractères hexadécimaux - sans compter les zéros en tête.

Le tableau et le paragraphe suivant ont été traduits des Microsoft Visual C++ 6.0 Docs.

Tableau

Les tableaux sont des tableaux alloués dynamiquement d'éléments semblables à des variables. Ils sont contigus en mémoire. Contrairement au C ou au R, chacune de ces variables peuvent avoir un type différent. Les tableaux sont créés avec la fonction array. Les données sont accessibles par des indices.

> a = array(28, "alpha")
[0]     28
[1]     "alpha"
> a[0]
        28
> gettype(a)
        "array"
Liste

Les listes sont implémentées comme des listes chaînées. Elles sont créées avec la fonction list. Les données sont accessibles par des indices.

> b = list(3, 2, 1)
[0]     3
[1]     2
[2]     1
> b[2] = 0
        0
> b
[0]     3
[1]     2
[2]     0
Objet

Les objets sont créés avec la fonction names. Un objet est un groupe de variables, accessibles avec l'opérateurs point (.). Si un membre d'un objet est une fonction, les variables accédées à l'intérieur de cette fonction sont recherchées à l'intérieur le contexte de l'objet avant d'aller voir à l'extérieur.

> id = names("nom", "age")
[nom]   undefined
[age]   undefined
> id.nom = "Philippe"
        "Philippe"
> id.age = 29
        29
> id
[nom]   "Philippe"
[age]   29
> gettype(id)
        "object"
Pointeur vers un noeud

Une définition de fonction retourne un pointeur vers un noeud, ainsi qu'une liste pointillée généalogique. Un segment de code explicite donne aussi un pointeur vers un noeud. Les noeuds sont les éléments de base de l'arbre syntaxique du code. La structure de l'arbre syntaxique est illustrée dans la page Structure de l'arbre.

> a = parent
        0x378630
> gettype(a)
        "node pointer"
> b = function() print("hello")
        0x37f110
> gettype(b)
        "node pointer"
Pointeur vers une structure FILE

Un pointeur vers une structure FILE est donnée par la fonction fopen. Ce type est utilisé par les fonctions de manipulation de stream. Les identificateurs de stream prédéfinis stdin, stdout et stderr sont du type pointeur vers FILE.

Pointeur vers une fpos_t

Le type pointeur vers une fpos_t est exclusivement utilisé par les fonctions fgetpos et fsetpos. C'est une position dans un fichier.

Mémoire brute

La mémoire brute est un buffer alloué dynamiquement et peut être obtenu par les fonctions vartomem, memclone et memory. Chacun des octets de la mémoire brute peut être lu ou écrit avec l'opérateur subscript.

> a = memory(4)
> gettype(a)
        "raw memory"
> a[0]
        0x0
> a[0] = 0xe1
        0xe1
Octet

Un octet est représenté par un unsigned char et est le type reçu en applicant l'opérateur subscript en lecture à de la mémoire brute.

> a = memory(4)
> b = a[0]
        0x0
> gettype(b)
        "byte"
> (byte) 255
        0xff
Adresse de mémoire

L'adresse de mémoire est le type obtenu en applicant l'opérateur de adresse-de "&" à une variable de type mémoire brute ou chaîne de caractère à laquelle on a appliqué l'opérateur subscript.

> a = memory(4)
> &a[0]
        0x335128
> b = &a[1]
        0x335129
> gettype(b)
        "memory address"
> c = "abc"
        "abc"
> gettype(&c[0])
        "memory address"
Pointeur vers les types ci-haut.

Si vous appliquez l'opérateur d'adresse-de (&) à une variable de n'importe quel type donné ci-haut, vous allez obtenir un pointeur vers son espace en mémoire. Si vous appliquez l'opérateur d'indirection (*) à une variable contenant un pointeur, vous allez obtenir la valeur de la première variable.

Si vous appliquez l'opérateur d'adresse-de à une variable contenant un pointeur, vous allez obtenir un pointeur vers un pointeur. Avec ce résultat, vous pouvez appliquer l'opérateur d'indirection deux fois.

Si vous applquez l'opérateur d'adresse-de à une variable contenant un objet, vous pouvez accéder à son contenu avec le pointeur en utilisant l'opérateur de déréférence de structure (->).

Un nombre peut aussi être "casté" vers le type pointeur vers un des types de base du C. Pour le moment, nous ne pouvons pas "caster" vers pointeur vers une chaîne de caractères, un objet, un tableau ou une liste.

> a = 42
        42
> b = &a
        0x2d0838
> gettype(b)
        "double*"
> c = &b
        0x2d08d8
> gettype(c)
        "double**"
> **c
        42
> a = names("x", "y")
[x]     undefined
[y]     undefined
> b = &a
        0x2d0838
> b->x = 5
        5
> b->y = -5
        -5
> a
[x]     5
[y]     -5

retour au PCASTL