Que veut dire cette ligne ?

Version imprimable

30/08/2021, 11h48
boboss123

Que veut dire cette ligne ?

Bonjour,

Je débute en C++ mais je connais bien le C.

Que fait cette ligne exactement ?

Code:

static foo::expose::json::NamespaceNode ns_config(&ns_port, "config");

ce que j'ai compris, c'est que ça déclare en local dans le fichier .cxx : la fonction ns_config dans le spacename "foo::expose::json::NamespaceNode"
... ce que je ne comprends pas, c'est qu'il y a dans ce prototype des arguments, ça ne devrait pas être plutôt ça qu'il devrait y avoir ?

Code:

static foo::expose::json::NamespaceNode ns_config(ns_port_t * ns_port, char * str);

Merci d'avance
30/08/2021, 13h19
dalfab

Bonjour,

La ligne ne déclare pas une fonction mais définit une instance d'objet statique. Les deux paramètres sont des valeurs passées au constructeur de foo::expose::json::NamespaceNode.
Et, tu as raison si c'était une déclaration de fonction, les paramètres seraient alors des types ou des paramètres typés.

On aurait pu aussi l'écrire :

Code:

static auto ns_config = foo::expose::json::NamespaceNode(&ns_port, "config");

Qui est plus compréhensible quand on vient du C.
30/08/2021, 14h03
boboss123

ok, merci pour l'info ;)
... et effectivement la second écriture est beaucoup plus compréhensible, je ne vois pas trop l’intérêt de la première !

Bonjour,

J'ai aussi une interrogation sur cette déclaration de structure, je ne comprends pas exactement ce que ça fait :

Code:

1
2
3
4
5
6
7
struct Foo {
    typedef bla::expose::ParamList <
    bla::expose::ParamVal<bla_infos_t *>
    > P;
 
    //...
};

... ça fait quoi exactement les opérateurs < et > ?

Merci d'avance

Pour infos, déclaration du template ParamList :

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
 
 
namespace bla {
namespace expose {
 
	// ...
 
	template <typename... T>
	struct ParamList {
		typedef int (*get_t)(typename T::get_ptr_type...);
		typedef int (*set_t)(typename T::set_ptr_type...);
		typedef int (*add_t)(typename T::set_ptr_type...);
		typedef int (*def_t)(typename T::ptr_type...);
		typedef typename details::DelPtrTypeCalc<T...>::type del_t;
		typedef typename details::ItrPtrTypeCalc<T...>::type itr_t;
		typedef int (*json_get_all_t)(const bla::expose::json::Request *req,
										  bla::ostreamBuf *os);
 
		typedef typename details::KeyTypeList<T...>::type key_list;
		typedef typename details::ValTypeList<T...>::type val_list;
		static constexpr size_t key_cnt = details::KeyTypeList<T...>::size;
		static constexpr size_t val_cnt = details::ValTypeList<T...>::size;
	};
 
}  // namespace expose
}  // namespace bla

Pour information, j'ai quelques connaissances en langages orientés objets (java, vba, ...)

06/09/2021, 10h18
dalfab

Citation:

Envoyé par boboss123

... ça fait quoi exactement les opérateurs < et > ?

Le C++ n'est pas le C. Avant de passer il te faut peut-être apprendre le langage.
< et > dans l'exemple que tu donnes ne sont pas des opérateurs, ils permettent ici de fournir des paramètres de template. La métaprogrammation est un des paradigmes fondamentaux du C++.
06/09/2021, 13h14
boboss123

J'ai lu quelques tutos sur les templates mais je n'ai pas trouvé d'explication de ce qu'était les points de suspension dans "<typename... T>" (tous les exemples que j'ai vus n'en avaient pas).
De plus, je n'ai pas trouvé d'explication sur la signification de "> P"

Salut,

Pour te permettre de comprendre, sans te donner un cours complet sur les template, on va essayer de t'en expliquer le principe ;)

Il faut -- avant tout -- comprendre que les template vont nous faire "basculer" dans un paradigme appelé le "paradigme générique".

Ce paradigme nous permet -- essayons de faire aussi simple que possible -- de dire au compilateur quelque chose qui pourrait ressembler à

Citation:

Je ne sais pas encore quel est le type réel des données que je vais utiliser, mais je sais en revanche parfaitement bien comment je vais devoir les manipuler

Car, tu l'auras compris, C++ est "très à cheval" sur les types de données que l'on manipule: si tu lui dit que tu vas travailler avec un type A, il faut que beaucoup de conditions soient remplies pour qu'il accepte que tu lui passe un type B à la place.

Vu que tu viens du C, on pourrait faire un parallèle "très lointain" avec le type void * qui permet de prendre un pointeur sur "n'importe quel type" de donnée, mais sans avoir la possibilité avant d'avoir trouvé un moyen correct et efficace pour déterminer le type réel de la donnée.

Avec la programmation générique, nous pouvons donc écrire des fonctions et des structures qui vont utiliser des données dont nous ne savons pas encore -- au moment d'écrire le code -- quel en sera le type. Par exemple, une fonction min ou pourrait s'écrire sous la forme de
Code:

1 2 3 4 5 6 template <typename T> T min( T a, T b){ if(a < b) return a; return b; }
ou bien, nous pourrions créer une structure "coordonnée" qui contiennt les coordonnées sur les axes des X, des Y et des Z sous la forme de
Code:

1 2 3 4 5 6 template <typename T> struct Coord{ T x; T y; T z; };
Les chevrons ne sont pas ici les opérateur "plus petit" et "plus grands" mais interviennent dans la syntaxe de langage pour nous permettre de fournir une "liste de paramètre templates" à la fonction ou à la structure. Autrement dit, pour nous permettre d'indiquer le nombre de types différents de données ainsi qu'un nom qui nous permettra de quel type on parle (car on pourrait très bien avoir trois types de données différents, sous une forme proche de template <typename A, typename B, typename C>)

Dans le cas présent, le compilateur va donc se dire que la fonction ou la structure va utilise un type de donnée "dont on ignore tout" pour l'instant et que l'on identifie comme étant ... le type T.

Seulement, tu le sais sans doute si tu viens du C, le type d'une donnée va -- non seulement --déterminer la manière dont cette donnée peut être manipulée (on ne peut pas manipuler de la même manière un int et un char[15]) mais aussi -- et surtout dans le cas présent -- l'espace mémoire nécessaire à la représentation complète de la donnée que le type nous permet de représenter (un int et un float vont demander un nombre de byte différent pour pouvoir être représenté en mémoire).

Et, comme le compilateur ne sait pas quel est le type réel de donnée qui se cache derrière ce type générique identifié par T, ben, il est -- tout bonnement -- incapable de générer le code binaire exécutable qui sera adapté à ce type réel (merci lapalisse :D ).

Et du coup, ben, si on veut pouvoir utiliser structure coord avec un type de donnée particulier (un int, un float, ou peut être même un double), il faudra que nous précisions explicitement quel est le type "réel" qui se cache derrière T.

Cela nous donnera donc un code proche de
Code:

1 2 3 Coord <int> maCoordInt; // x, y et z sont des données de type int Coord <float> maCoordFloat; // x, y et z sont des données de type float Coord <double> maCoordInt; // x, y et z sont des données de type double
Encore une fois, < et > n'ont rien à voir avec les opérateur de comparaison "plus petit" ou "plus grand" : il sont un élément de la syntaxe qui permet au développeur d'indiquer le type de la donnée qui sera réellement utilisé, et dont on ignorait tout au moment de créer notre structure Coord.

Et donc, quand tu trouve un code proche de
Code:

1 2 3 4 5 6 7 struct Foo { typedef bla::expose::ParamList < bla::expose::ParamVal<bla_infos_t *> > P; //... };
Hé bien, on va définir P comme étant un alias du type (c'est le but de typedef, n'est-ce pas :question: :D) bla::expose::ParamList "spécialisé" pour travailler avec des données qui seront de type bla::expose::ParamVal<bla_infos_t *>(qui est lui même le type bla::expose::ParamVal "spécialisé" pour travailler avec des données de type bla_infos_t *).

Et si tu veux savoir à quoi correspond tout cela, ben il faudra arriver à "remonter le courant" pour savoir à quoi correspond bla_infos_t parce que c'est sans doute aussi l'alias d'un type "dont on ignore tout" qui est fourni par la liste des paramètres template.

Et donc, pour conclure, le code
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 namespace bla { namespace expose { // ... template <typename... T> struct ParamList { typedef int (*get_t)(typename T::get_ptr_type...); typedef int (*set_t)(typename T::set_ptr_type...); typedef int (*add_t)(typename T::set_ptr_type...); typedef int (*def_t)(typename T::ptr_type...); typedef typename details::DelPtrTypeCalc<T...>::type del_t; typedef typename details::ItrPtrTypeCalc<T...>::type itr_t; typedef int (*json_get_all_t)(const bla::expose::json::Request *req, bla::ostreamBuf *os); typedef typename details::KeyTypeList<T...>::type key_list; typedef typename details::ValTypeList<T...>::type val_list; static constexpr size_t key_cnt = details::KeyTypeList<T...>::size; static constexpr size_t val_cnt = details::ValTypeList<T...>::size; }; } // namespace expose } // namespace bla
va déclarer une structure de de type ParamList pour qui utilisera "un nombre inconnu" de types de données "dont on ignore tout" (le code typename ... T) et qui déclarera en interne une série d'alias de type bien particuliers (c'est ce que l'on appelle une spécialisation totale), basée sur la liste de ces types dont "on ignore tout" et que l'on a identifié par T.

Cette structure se trouve dans "une boite de rangement" (un "espace de noms") qui est appelée expose, et qui se trouve elle-même dans une boite de rangement (un "espace de noms" appelée bla.

Si tu es "à l'extérieur" de la boîte de rangement nommé bla et que tu veux utiliser cette structure ParamList, il faudra donc que tu y accède en entrant dans la boite bla, puis dans la boite expose, et, bien sur, que tu n'oublie pas de fournir les types réels qui seront utilisés, par exemple
Code:

1 2 3 auto lesParam = bla::expose::ParamList<int, float double>; // lesParam manipule trois données, respectivement // de type int, float et double, // et expose en outre en interne une série d'alias de type et d'expression constantes pour chacun de ces trois paramètre

06/09/2021, 16h54
jo_link_noir

Plutôt que regarder des tutos sur tel ou tel partie, je pense qu'il est préférable de commencer par un cours C++ de A à Z. Les philosophies de C et C++ sont très différentes et la manière d'aborder les choses aussi. Le point primordial est d'oublier le C.

Pour le cours, il en faut un qui commence au minimum par C++11 au risque de tomber sur des cours obsolètes.
06/09/2021, 16h54
Invité
Citation:

Envoyé par boboss123

J'ai lu quelques tutos sur les templates mais je n'ai pas trouvé d'explication de ce qu'était les points de suspension dans "<typename... T>" (tous les exemples que j'ai vus n'en avaient pas).
De plus, je n'ai pas trouvé d'explication sur la signification de "> P"

"..." est un argument variadique, il permet à une fonction d'accepter un nombre quelconque d'arguments supplémentaires.

Concernant "> P". il suffit de lire le code en entier :
Code:

1 2 3 typedef bla::expose::ParamList < bla::expose::ParamVal<bla_infos_t *> > P;
C'est un Template dont le code est détaillé sur plusieurs ligne pour un soucis de visibilité.
07/09/2021, 09h15
boboss123

Merci pour vos explications, je pense avoir tout compris ;)
... et effectivement, il faudrait que je mette à lire intégralement un cours de C++