struct

Tableau de structures

Description

Un tableau de structures est un type de données qui regroupe des données associées dans des conteneurs de données appelés champs. Chaque champ peut contenir n’importe quel type de données. Accédez aux données d’un champ avec une notation pointée de la forme structName.fieldName.

Création

Lorsque vous avez des données à intégrer dans une nouvelle structure, créez la structure en utilisant la notation pointée pour nommer ses champs un par un :

s.a = 1;
s.b = {'A','B','C'}

s = struct with fields:
    a: 1
    b: {'A'  'B'  'C'}

Les noms de champs peuvent contenir des lettres ASCII (A-Z, a-z), des chiffres (0-9) et des underscores. Ils doivent commencer par une lettre. La longueur maximale d’un nom de champ est namelengthmax.

Vous pouvez également créer un tableau de structures avec la fonction struct décrite ci-dessous. Vous pouvez spécifier de nombreux champs à la fois ou créer un tableau de structures non scalaire.

Syntaxe

s = struct

s = struct(field,value)

s = struct(field1,value1,...,fieldN,valueN)

s = struct([])

s = struct(obj)

Description

s = struct crée une structure scalaire (1 x 1) ne contenant aucun champ.

s = struct(field,value) crée un tableau de structures avec le champ et la valeur spécifiés. L’argument en entrée value peut contenir n’importe quel type de données, par exemple numérique, logique, caractère ou cell array.

• Si value n’est pas un cell array ou si value est un cell array scalaire, s est une structure scalaire. Par exemple, s = struct('a',[1 2 3]) crée une structure de 1 x 1 où s.a = [1 2 3].

• Si value est un cell array non scalaire, s est un tableau de structures de mêmes dimensions que value. Chaque élément de s contient l’élément correspondant de value. Par exemple, s = struct('x',{'a','b'}) renvoie s(1).x = 'a' et s(2).x = 'b'.

• Si value est un cell array vide {}, s est une structure vide (0 x 0).

s = struct(field1,value1,...,fieldN,valueN) crée un tableau de structures avec plusieurs champs.

• Si aucune des entrées de value n’est un cell array ou si toutes les entrées de value qui sont des cell arrays sont scalaires, s est une structure scalaire.

• Si l’une des entrées de value est un cell array non scalaire, s a les mêmes dimensions que ce cell array. Par ailleurs, si plusieurs entrées de value sont des cell arrays non scalaires, elles doivent toutes avoir les mêmes dimensions.

  Pour toute entrée de value qui est un cell array scalaire ou un tableau de tout autre type de données, struct insère le contenu de value dans le champ approprié pour tous les éléments de s. Par exemple, s = struct('x',{'a','b'},'y','c') renvoie s(1).x = 'a', s(2).x = 'b', s(1).y = 'c' et s(2).y = 'c'.

• Si une entrée de value est un cell array vide {}, la sortie s est une structure vide (0 x 0). Pour spécifier un champ vide et conserver les valeurs des autres champs, utilisez plutôt [] en tant qu’entrée de value.

s = struct([]) crée une structure vide (0 x 0) ne contenant aucun champ.

s = struct(obj) crée une structure scalaire contenant des noms de champs et des valeurs qui correspondent aux propriétés de obj. La fonction struct ne convertit pas, obj mais crée plutôt s en tant que nouvelle structure. Cette structure ne conserve pas les informations relatives aux classes. Par conséquent, les propriétés privées, protégées et masquées deviennent des champs publics dans s. La fonction struct génère un avertissement lorsque vous utilisez cette syntaxe.

Arguments en entrée

field — Nom du champ

vecteur de caractères | string scalar

Nom du champ, spécifié sous forme de vecteur de caractères ou de string scalar.

value — Valeurs

tableau

Valeurs, spécifiées sous forme de tableau de n’importe quel type. Si une entrée de value est un cell array non scalaire, toutes les entrées qui sont des cell arrays non scalaires doivent avoir les mêmes dimensions.

Si une entrée de value est un cell array vide {}, la sortie est un tableau de structures vide. Pour spécifier un seul champ vide, utilisez [].

obj — Objet

objet

La fonction struct copie les propriétés de obj dans les champs d’une nouvelle structure scalaire.

La fonction struct ne crée pas de structure à partir de la plupart des types de données fondamentaux. Par exemple, si obj a le type de données double ou char, struct génère un message d’erreur. Toutefois, struct renvoie bien les propriétés d’une table ou d’une timetable sous forme de structure. Pour la liste des types de données fondamentaux, consultez Fundamental MATLAB Classes.

Exemples

Stocker des variables de données associées dans une structure

Stockez des données associées dans les champs d’une structure. Vous pouvez attribuer aux champs des noms lisibles par l’humain qui décrivent les données.

Créez une structure en lui ajoutant des champs avec la notation pointée. Les champs contiennent les valeurs x et y d’une onde sinusoïdale ainsi que du texte décrivant les données.

data.x = linspace(0,2*pi);
data.y = sin(data.x);
data.title = 'y = sin(x)'

data = struct with fields:
        x: [0 0.0635 0.1269 0.1904 0.2539 0.3173 0.3808 0.4443 0.5077 0.5712 0.6347 0.6981 0.7616 0.8251 0.8885 0.9520 1.0155 1.0789 1.1424 1.2059 1.2693 1.3328 1.3963 1.4597 1.5232 1.5867 1.6501 1.7136 1.7771 1.8405 1.9040 1.9675 … ] (1×100 double)
        y: [0 0.0634 0.1266 0.1893 0.2511 0.3120 0.3717 0.4298 0.4862 0.5406 0.5929 0.6428 0.6901 0.7346 0.7761 0.8146 0.8497 0.8815 0.9096 0.9341 0.9549 0.9718 0.9848 0.9938 0.9989 0.9999 0.9969 0.9898 0.9788 0.9638 0.9450 0.9224 … ] (1×100 double)
    title: 'y = sin(x)'

Tracez l’onde sinusoïdale. Vous pouvez faire référence aux tableaux de valeurs x et y par leurs noms de champs. Ajoutez ensuite le titre.

plot(data.x,data.y)
title(data.title)

Structure à champ unique

Créez une structure non scalaire contenant un seul champ.

field = 'f';
value = {'some text';
         [10, 20, 30];
         magic(5)};
s = struct(field,value)

s=3×1 struct array with fields:
    f

Affichez le contenu de chaque élément.

s.f

ans = 
'some text'

ans = 1×3

    10    20    30

ans = 5×5

    17    24     1     8    15
    23     5     7    14    16
     4     6    13    20    22
    10    12    19    21     3
    11    18    25     2     9

Lorsque vous accédez à un champ d’une structure non scalaire, par exemple s.f, MATLAB® renvoie une liste d’éléments séparés par des virgules. Dans ce cas, s.f est équivalent à s(1).f, s(2).f, s(3).f.

Structure à champs multiples

Créez une structure non scalaire contenant plusieurs champs.

field1 = 'f1';  value1 = zeros(1,10);
field2 = 'f2';  value2 = {'a', 'b'};
field3 = 'f3';  value3 = {pi, pi.^2};
field4 = 'f4';  value4 = {'fourth'};

s = struct(field1,value1,field2,value2,field3,value3,field4,value4)

s=1×2 struct array with fields:
    f1
    f2
    f3
    f4

Les cell arrays pour value2 et value3 sont de dimension 1 x 2, donc s est aussi de dimension 1 x 2. Comme value1 est un tableau numérique et non un cell array, s(1).f1 et s(2).f1 ont un contenu identique. De même, comme le cell array pour value4 contient un seul élément, s(1).f4 et s(2).f4 ont un contenu identique.

s(1)

ans = struct with fields:
    f1: [0 0 0 0 0 0 0 0 0 0]
    f2: 'a'
    f3: 3.1416
    f4: 'fourth'

s(2)

ans = struct with fields:
    f1: [0 0 0 0 0 0 0 0 0 0]
    f2: 'b'
    f3: 9.8696
    f4: 'fourth'

Structure à champ vide

Créez une structure contenant un champ vide. Utilisez [] pour spécifier la valeur du champ vide.

s = struct('f1','a','f2',[])

s = struct with fields:
    f1: 'a'
    f2: []

Champs contenant des cell arrays

Créez une structure avec un champ contenant un cell array.

field = 'mycell';
value = {{'a','b','c'}};
s = struct(field,value)

s = struct with fields:
    mycell: {'a'  'b'  'c'}

Structure vide

Créez une structure vide contenant plusieurs champs.

s = struct('a',{},'b',{},'c',{})

s = 

  0×0 empty struct array with fields:

    a
    b
    c

Affectez une valeur à un champ dans une structure vide.

s(1).a = 'a'

s = struct with fields:
    a: 'a'
    b: []
    c: []

Structure imbriquée

Créez une structure imbriquée où a est une structure avec un champ contenant une autre structure.

a.b = struct('c',{},'d',{})

a = struct with fields:
    b: [0×0 struct]

Affichez les noms des champs de a.b.

fieldnames(a.b)

ans = 2×1 cell
    {'c'}
    {'d'}

Capacités étendues

Génération de code C/C++

Générez du code C et C++ avec MATLAB® Coder™.

Notes d’usage et limitations :

• Si l’argument value est un cell array, tous les éléments doivent être du même type.

• Les noms des champs d’un struct array doivent être de même longueur. Par exemple, le code suivant génère une erreur, car 'my_int' et 'my_double' n’ont pas la même longueur :

  param1.name = 'my_int';
  param1.value = int32(1);
  param2.name = 'my_double';
  param2.value = 2.0;
  params = [param1, param2];

Environnement basé sur les threads

Exécutez du code en arrière-plan avec MATLAB® backgroundPool ou accélérez le code avec Parallel Computing Toolbox™ ThreadPool.

Cette fonction supporte entièrement les environnements basés sur des threads. Pour plus d’informations, consultez Run MATLAB Functions in Thread-Based Environment.

Historique des versions

Introduit avant R2006a

R2023b: Affichage du contenu partiel, en plus de la taille et du type de données des tableaux, dans les champs de structure

Entre les versions R2021b et R2023b, MATLAB^® affichait l’intégralité du contenu d’un tableau dans un champ de structure si celui-ci tenait à l’écran. Si le tableau était trop grand, MATLAB affichait autant de contenu que le permettait l’écran.

Depuis la version R2023b, si l’intégralité du contenu d’un tableau dans un champ ne tient pas à l’écran, MATLAB affiche autant de contenu que le permet l’écran ainsi que la taille et le type de données du tableau. Par exemple, depuis la version R2023b, MATLAB affiche le contenu partiel ainsi que la taille et le type de données pour deux champs contenant des tableaux de 100 valeurs doubles.

data.x = linspace(0,2*pi);
data.y = sin(data.x);
data

data = 

  struct with fields:

    x: [0 0.0635 0.1269 0.1904 0.2539 0.3173 0.3808 … ] (1×100 double)
    y: [0 0.0634 0.1266 0.1893 0.2511 0.3120 0.3717 … ] (1×100 double)

Si le premier élément du tableau est lui-même trop grand pour être affiché, par exemple un membre d’une énumération dont le nom est long, MATLAB affiche seulement la taille et le type de données du tableau.

La fonction disp a le même comportement.

R2021b: Affichage du contenu partiel des tableaux dans les champs de structure au lieu de la taille et du type de données

Avant la version R2021b, MATLAB affichait l’intégralité du contenu d’un tableau dans un champ de structure si celui-ci tenait à l’écran. Si le tableau était trop grand, MATLAB affichait la taille et le type de données du tableau.

Depuis la version R2021b, si l’intégralité du contenu d’un tableau ne tient pas à l’écran, MATLAB affiche autant de contenu que l’écran le permet au lieu de la taille et du type de données. Par exemple, depuis la version R2021b, MATLAB affiche le contenu partiel de deux champs de structure contenant des tableaux de 100 valeurs doubles.

data.x = linspace(0,2*pi);
data.y = sin(data.x);
data

data = 

  struct with fields:

     x: [0 0.0635 0.1269 0.1904 0.2539 0.3173 0.3808 0.4443 0.5077 … ]
     y: [0 0.0634 0.1266 0.1893 0.2511 0.3120 0.3717 0.4298 0.4862 … ]

Si le premier élément du tableau est lui-même trop grand pour être affiché, par exemple un membre d’une énumération dont le nom est long, MATLAB affiche seulement la taille et le type de données du tableau.

La fonction disp a le même comportement.

R2019a: Expansion de tableau de structures cohérente avec l’expansion de tableau ordinaire

Depuis la version R2019a, les dimensions d’un tableau de structures étendu sont cohérentes que vous affectiez une valeur à un seul champ avec la notation pointée ou que vous affectiez une structure entière au tableau. Auparavant, les dimensions en sortie étaient différentes lorsque vous ne spécifiiez pas d’indices pour toutes les dimensions. L’affectation à un champ avec la notation pointée a désormais le comportement précédent de l’affectation d’une structure, lequel est cohérent avec l’expansion de tableau ordinaire. Par exemple :

• Si S est de dimension 1 x 2 x 3 x 4, S(5,2)=struct('a',3) et S(5,2).a=3 étendent tous les deux S à 5 x 2 x 3 x 4. Auparavant, S(5,2).a=3 générait un tableau de 5 x 24.

• Si S est de dimension 0 x 5 ou 5 x 0, S(3)=struct('a',2) et S(3).a=2 étendent tous les deux S à 1 x 3. Auparavant, S(3).a=1 générait un tableau de 1 x 5 quand S était de dimension 0 x 5 et un tableau de 3 x 1 quand S était de dimension 5 x 0.

• Si S est de dimension 0 x 2 x 3, S(3) = struct('a',2) et S(3).a=2 génèrent des erreurs, car la dimension à étendre est ambiguë. Auparavant, S(3).a=2 générait un tableau de 1 x 6.

• Si S est de dimension 1 x 1 x 3 avec deux champs, S(5)=struct('a',7,'b',[]) et S(5).a=7 étendent tous les deux S à 1 x 1 x 5. Auparavant, S(5).a=7 générait un tableau de 1 x 5.

• Si S est de dimension 0 x 1 avec deux champs, S(5)=struct('a',7,'b',[]) et S(5).a=7 étendent tous les deux S à 5 x 1. Auparavant, S(5).a=7 générait un tableau de 1 x 5.

Voir aussi

isfield | table | isstruct | fieldnames | orderfields | rmfield | substruct | cell2struct | struct2cell | struct2table | table2struct | namelengthmax

Rubriques

• Tableaux de structures
• Access Data in Nested Structures
• Générer des noms de champs à partir de variables