Un question sur les classes

Bonjour,

Si une fonction membre d'une classe a besoin d'un tableau de structures de données par exemple, où le définissez-vous (sachant que ce tableau doit resté privé) , puisqu'il n 'est pas possible de le faire dans le corps de la classe ?

Willy.

Si le tableau n'est utile qu'a la fonction, déclare le dans la fonction.

Ça dépend de la fréquence d'appel de la fonction, non ?

Parfois, il vaut mieux s'économiser des allocations.

+1 pour oodini.

Je dirais que tout dépend de l'utilisation du tableau.
willycat, Est-ce qu'il serait possible d'avoir plus de précision du contexte?

Citation:

Envoyé par oodini

Ça dépend de la fréquence d'appel de la fonction, non ?

Parfois, il vaut mieux s'économiser des allocations.

Pas si le tableau en question est constant. Si c'est pas le cas effectivement mieu vaut l'avoir en membre.

Nope. Das ce cas un tableau static const local à la fonction est plus approprié.

Bonjour,

en fait, c'est plus une question d'ordre général plutôt que relative à un contexte en particulier. Il n'y a pas si longtemps que j'ai débuté en c++ et j'arrive à un stade où, dans mon projet récemment commencé, je me pose la question de savoir où définir les données utilisées par les fonctions membres d'une classe, puisque dans la définition de la classe, cela n' est pas possible (sauf pour des données entières déclarées "static const") et que ces données doivent rester privées.

Par exemple, soit une classe "terminal_t" pour la gestion d'un terminal disposant de membres privées et de fonctions membres privées et publiques dont deux d'entre-elles permettent l'envoie et la réception de caractères. Pour leur fonctionnement, ces fonctions ont besoin de tableaux de données comme des tableaux de caractères ASCII et d'autres pour la reconnaissance des codes de contrôle. Or, où les définir sachant que ces données sont utilisées par plusieurs fonctions membres et qu'elles doivent être privées ?

Actuellement, je songe à cette solution:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class terminal_t { ... const mystruct *ptr; ... }; terminal_t::terminal_t() { static const mystruct data[] = { ... }; ptr = data; }
mais je trouve cette solution un peu bancale. Qu'en pensez-vous ?

Merci,

Willy.

Citation:

Envoyé par willycat

je me pose la question de savoir où définir les données utilisées par les fonctions membres d'une classe, puisque dans la définition de la classe, cela n' est pas possible

Comment ça ? Pourquoi cela ne serait-il pas possible ? C'est le principe de l'encapsulation.
Y'a quelque chose que j'ai dû mal comprendre... :-/

je ne sais pas si cela peut aider et que j'ai bien compris ce que tu as écris, mais le fait qu'un attribut soit privé n'a pas d'importance à l'intérieur de la classe. Ainsi une méthode de la même classe peut accéder sans problème à la donnée membre privé.

Ainsi, un scénario classique :
définition d'un tableau privé dans la classe,
Le constructeur ou une méthode d'initialisation permet d'initialiser le tableau,
La ou les fonctions ayant besoin du tableau l'utilise.
Ceci permet d'avoir une certaine souplesse pour l'initialisation qui peut se faire dynamiquement (lecture d'un fichier, entrée utilisateur, données calculées, ...) et évite d'écrire en dur dans le programme.

Y a t'il un intérêt particulier à avoir un tableau static const ?

Citation:

Envoyé par Davidbrcz

Nope. Das ce cas un tableau static const local à la fonction est plus approprié.

D'un point de vue implémentation par le compilateur, ça ne reviens pas au même?

Afin de bien me faire comprendre, voici un morceau de la classe en question sur laquelle je travaille:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
class term_t
{
  enum parser_state_t
  {
    SAME,
    ANYWHERE,
    CSI_ENTRY,
    CSI_IGNORE,
    CSI_INTERMEDIATE,
    CSI_PARAM,
    DCS_ENTRY,
    DCS_IGNORE,
    DCS_INTERMEDIATE,
    DCS_PARAM,
    DCS_PASSTHROUGH,
    ESCAPE,
    ESCAPE_INTERMEDIATE,
    GROUND,
    OSC_STRING,
    SOS_PM_APC_STRING,
  };

  enum parser_action_t
  {
    NONE,
    CLEAR,
    COLLECT,
    CSI_DISPATCH,
    ESC_DISPATCH,
    EXECUTE,
    HOOK,
    IGNORE,
    OSC_END,
    OSC_PUT,
    OSC_START,
    PARAM,
    PRINT,
    PUT,
    UNHOOK,
  };

  struct parser_event_t
  {
    char min;
    char max;
    parser_action_t action;
    parser_state_t state;
  };

  struct termchar_t
  {
    short c:8;
    short front:4;
    short back:4;
  };

  short forground;
  short background;

  /* ... */

  const parser_event_t **parser_events;

public:

  void put_char(int c);

  void put_str(const char *str);

  term_t(int serial_port = 0, int serial_speed = 115200);
};

Et son constructeur:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
term_t::term_t(int serial_port, int serial_speed)
{
  static const parser_event_t state_anywhere[] =
  {
    { 0x18, 0x18, EXECUTE  , GROUND            },
    { 0x1a, 0x1a, EXECUTE  , GROUND            },
    { 0x1b, 0x1b, NONE    , ESCAPE            },
    { 0x80, 0x8f, EXECUTE  , GROUND            },
    { 0x90, 0x90, NONE    , DCS_ENTRY          },
    { 0x91, 0x97, EXECUTE  , GROUND            },
    { 0x98, 0x98, NONE    , SOS_PM_APC_STRING  },
    { 0x99, 0x9a, EXECUTE  , GROUND            },
    { 0x9b, 0x9b, NONE    , CSI_ENTRY          },
    { 0x9c, 0x9c, EXECUTE  , GROUND            },
    { 0x9d, 0x9d, NONE    , OSC_STRING        },
    { 0x9e, 0x9f, NONE    , SOS_PM_APC_STRING  }
  };

  static const parser_event_t state_csi_entry[] =
  {
    { 0x00, 0x07, EXECUTE        , SAME              },
    { 0x19, 0x19, EXECUTE        , SAME              },
    { 0x1c, 0x1f, EXECUTE        , SAME              },
    { 0x20, 0x2f, COLLECT        , CSI_INTERMEDIATE  },
    { 0x30, 0x39, PARAM          , CSI_PARAM          },
    { 0x3a, 0x3a, NONE          , CSI_IGNORE        },
    { 0x3b, 0x3b, PARAM          , CSI_PARAM          },
    { 0x3c, 0x3f, COLLECT        , CSI_PARAM          },
    { 0x40, 0x7e, CSI_DISPATCH  , GROUND            },
    { 0x7f, 0x7f, IGNORE        , SAME              }
  };

  static const parser_event_t state_csi_ignore[] =
  {
    { 0x00, 0x17, EXECUTE  , SAME    },
    { 0x19, 0x19, EXECUTE  , SAME    },
    { 0x1c, 0x1f, EXECUTE  , SAME    },
    { 0x20, 0x3f, IGNORE  , SAME    },
    { 0x40, 0x7e, NONE    , GROUND  },
    { 0x7f, 0x7f, IGNORE  , SAME    }
  };

  static const parser_event_t state_csi_intermediate[] =
  {
    { 0x00, 0x17, EXECUTE        , SAME        },
    { 0x19, 0x19, EXECUTE        , SAME        },
    { 0x1c, 0x2f, EXECUTE        , SAME        },
    { 0x30, 0x3f, NONE          , CSI_IGNORE  },
    { 0x40, 0x7e, CSI_DISPATCH  , GROUND      },
    { 0x7f, 0x7f, IGNORE        , SAME        }
  };

  static const parser_event_t state_csi_param[] =
  {
    { 0x00, 0x17, EXECUTE        , SAME        },
    { 0x19, 0x19, EXECUTE        , SAME        },
    { 0x1c, 0x2f, EXECUTE        , SAME        },
    { 0x30, 0x39, PARAM          , SAME        },
    { 0x3a, 0x3a, NONE          , CSI_IGNORE  },
    { 0x3b, 0x3b, PARAM          , SAME        },
    { 0x3c, 0x3f, NONE          , CSI_IGNORE  },
    { 0x40, 0x7e, CSI_DISPATCH  , GROUND      },
    { 0x7f, 0x7f, IGNORE        , SAME        }
  };

  static const parser_event_t state_dcs_entry[] =
  {
    { 0x00, 0x17, IGNORE  , SAME              },
    { 0x19, 0x19, IGNORE  , SAME              },
    { 0x1c, 0x1f, IGNORE  , SAME              },
    { 0x20, 0x2f, COLLECT  , DCS_INTERMEDIATE  },
    { 0x30, 0x39, PARAM    , DCS_PARAM          },
    { 0x3a, 0x3a, NONE    , DCS_IGNORE        },
    { 0x3b, 0x3b, PARAM    , DCS_PARAM          },
    { 0x3c, 0x3f, COLLECT  , DCS_PARAM          },
    { 0x40, 0x7e, NONE    , DCS_PASSTHROUGH    },
    { 0x7f, 0x7f, IGNORE  , SAME              }
  };

  static const parser_event_t state_dcs_ignore[] =
  {
    { 0x00, 0x17, IGNORE  , SAME    },
    { 0x19, 0x19, IGNORE  , SAME    },
    { 0x1c, 0x7f, IGNORE  , SAME    },
    { 0x9c, 0x9c, NONE    , GROUND  }
  };

  static const parser_event_t state_dcs_intermediate[] =
  {
    { 0x00, 0x17, IGNORE  , SAME        },
    { 0x19, 0x19, IGNORE  , SAME        },
    { 0x1c, 0x1f, IGNORE  , SAME        },
    { 0x20, 0x2f, COLLECT  , SAME        },
    { 0x30, 0x7e, NONE    , DCS_IGNORE  },
    { 0x7f, 0x7f, IGNORE  , SAME        }
  };

  static const parser_event_t state_dcs_param[] =
  {
    { 0x00, 0x17, IGNORE  , SAME              },
    { 0x19, 0x19, IGNORE  , SAME              },
    { 0x1c, 0x1f, IGNORE  , SAME              },
    { 0x20, 0x2f, COLLECT  , DCS_INTERMEDIATE  },
    { 0x30, 0x39, PARAM    , SAME              },
    { 0x3a, 0x3a, NONE    , DCS_IGNORE        },
    { 0x3b, 0x3b, PARAM    , SAME              },
    { 0x3c, 0x3f, NONE    , DCS_IGNORE        },
    { 0x40, 0x7e, NONE    , DCS_PASSTHROUGH    },
    { 0x7f, 0x7f, IGNORE  , SAME              }
  };

  static const parser_event_t state_dcs_passthrough[] =
  {
    { 0x00, 0x17, PUT      , SAME    },
    { 0x19, 0x19, PUT      , SAME    },
    { 0x1c, 0x7e, PUT      , SAME    },
    { 0x7f, 0x7f, IGNORE  , SAME    },
    { 0x9c, 0x9c, NONE    , GROUND  }
  };

  static const parser_event_t state_escape[] =
  {
    { 0x00, 0x17, EXECUTE        , SAME                },
    { 0x19, 0x19, EXECUTE        , SAME                },
    { 0x1c, 0x1f, EXECUTE        , SAME                },
    { 0x20, 0x2f, COLLECT        , ESCAPE_INTERMEDIATE  },
    { 0x30, 0x4f, ESC_DISPATCH  , GROUND              },
    { 0x50, 0x50, NONE          , DCS_ENTRY            },
    { 0x51, 0x57, ESC_DISPATCH  , GROUND              },
    { 0x58, 0x58, NONE          , SOS_PM_APC_STRING    },
    { 0x59, 0x5a, ESC_DISPATCH  , GROUND              },
    { 0x5b, 0x5b, NONE          , CSI_ENTRY            },
    { 0x5c, 0x5c, ESC_DISPATCH  , GROUND              },
    { 0x5d, 0x5d, NONE          , OSC_STRING          },
    { 0x5e, 0x5f, NONE          , SOS_PM_APC_STRING    },
    { 0x60, 0x7e, ESC_DISPATCH  , GROUND              },
    { 0x7f, 0x7f, IGNORE        , SAME                }
  };

  static const parser_event_t state_escape_intermediate[] =
  {
    { 0x00, 0x17, EXECUTE        , SAME    },
    { 0x19, 0x19, EXECUTE        , SAME    },
    { 0x1c, 0x1f, EXECUTE        , SAME    },
    { 0x20, 0x2f, COLLECT        , SAME    },
    { 0x30, 0x7e, ESC_DISPATCH  , GROUND  },
    { 0x7f, 0x7f, IGNORE        , SAME    }
  };

  static const parser_event_t state_ground[] =
  {
    { 0x00, 0x17, EXECUTE  , SAME },
    { 0x19, 0x19, EXECUTE  , SAME },
    { 0x1c, 0x1f, EXECUTE  , SAME },
    { 0x20, 0x7f, PRINT    , SAME },
    { 0x80, 0x8f, EXECUTE  , SAME },
    { 0x91, 0x9a, EXECUTE  , SAME },
    { 0x9c, 0x9c, EXECUTE  , SAME }
  };

  static const parser_event_t state_osc_string[] =
  {
    { 0x00, 0x17, IGNORE  , SAME    },
    { 0x19, 0x19, IGNORE  , SAME    },
    { 0x1c, 0x1f, IGNORE  , SAME    },
    { 0x20, 0x7f, OSC_PUT  , SAME    },
    { 0x9c, 0x9c, NONE    , GROUND  }
  };

  static const parser_event_t state_sos_pm_apc_string[] =
  {
    { 0x00, 0x17, IGNORE  , SAME    },
    { 0x19, 0x19, IGNORE  , SAME    },
    { 0x1c, 0x7f, IGNORE  , SAME    },
    { 0x9c, 0x9c, NONE    , GROUND  }
  };

  static const parser_event_t *events[] =
  {
    state_anywhere,
    state_csi_entry,
    state_csi_ignore,
    state_csi_intermediate,
    state_csi_param,
    state_dcs_entry,
    state_dcs_ignore,
    state_dcs_intermediate,
    state_dcs_param,
    state_dcs_passthrough,
    state_escape,
    state_escape_intermediate,
    state_ground,
    state_osc_string,
    state_sos_pm_apc_string
  };

  parser_events = events;

  /* ... */
};

Ma question porte en fait sur l'emplacement de la définition du tableau "events": Il faut qu'il soit privé et accessible à d'autres fonctions membres, ce qui est le cas dans ce code mais je trouve vraiment curieux de devoir mélanger les donnée avec du code, et c'est pourquoi je demande votre avis.

Et pour l'utilisation du type "static const":
- const parqu'il s'agit de données non modifiables.
- static parceque le tableau "events" doit exister en dehors du constructeur.

Willy.