PLOOC
v4.6.4 Minor Improvement
Programmation protégée orientée objet à faible tête de tête avec ANSI-C, connue sous le nom de Plooc ['Plu: K], est un ensemble de modèles de macro C bien polis qui:
Remarque: Cette protection peut être désactivée en définissant la macro
__OOC_DEBUG__pour faciliter le débogage.
_Generic .Remarque: les frais généraux sont presque nuls. Le modèle utilise entièrement les règles de compilation forcées d'ANSI-C pour fournir des fonctionnalités orientées objet avec un coût nécessaire minimal.
- Suitable for both bare-metal and RTOS environments.
- Suitable for both 8-bit and 32-bit MCUs.
Le concept de C (OOC) orienté objet n'est pas nouveau. Il existe de nombreuses bibliothèques, SDK et modèles qui étendent ANSI-C avec des fonctionnalités de programmation orientées objet. Bien que PLOOC mette l'accent sur sa faible surcharge dans la taille et les performances du code, de nombreuses solutions OOC à base de macro offrent également de faibles frais généraux. PLOOC ne vous oblige pas à utiliser la gestion de la mémoire de tas ou de pool, ni de fournir des fonctionnalités de collecte de déchets (GC), laissant ces options à l'utilisateur. Cela le permet même pour les systèmes 8 bits. Bien que certains puissent voir cela comme un inconvénient, c'est un choix de conception délibéré. Je ne dirai pas à ce sujet.
Alors, qu'est-ce qui distingue Plooc des autres? Est-ce simplement une autre roue réinventée?
La réponse est non.
Plooc présente une fonctionnalité unique qui manque à la plupart des autres solutions: elle garantit que les membres privés d'une classe sont vraiment privés et protégés. Cela signifie que les utilisateurs en dehors du code source de classe sont empêchés d'accéder à ces membres privés. Au lieu de cela, ils ne voient qu'un bloc de mémoire solide, masqué comme un tableau d'octets. Étant donné que les classes en C sont imitées par les structures, Plooc implémente des classes en utilisant une structure masquée. Comme prévu, seul le code source de classe peut accéder aux membres privés, et seul le code source de classe d'une classe dérivée peut accéder aux membres protégés de la classe de base. Les membres du public, cependant, sont accessibles à tous.
Comment cela marche-t-il? Vous l'avez peut-être deviné du terme «structure masquée». Essentiellement, c'est une astuce de filage de type dans les fichiers d'en-tête.
Cette astuce fonctionne bien jusqu'à ce qu'elle rencontre un compilateur de vérification de type strict. L'exemple le plus célèbre (ou notoire) est IAR, surtout lorsque le mode de compilation multi-fichiers est activé. Aucune astuce de tricherie ne peut survivre aux vérifications rigoureuses du mode de compilation multi-fichiers d'IAR.
//! The original structure in the class source code
struct byte_queue_t {
uint8_t *pchBuffer;
uint16_t hwBufferSize;
uint16_t hwHead;
uint16_t hwTail;
uint16_t hwCount;
};
//! The masked structure: the class byte_queue_t in the header file
typedef struct byte_queue_t {
uint8_t chMask [sizeof(struct {
uint8_t *pchBuffer;
uint16_t hwBufferSize;
uint16_t hwHead;
uint16_t hwTail;
uint16_t hwCount;
})];
} byte_queue_t;
Pour que cela fonctionne, vous devez vous assurer que le code source de classe n'inclut pas son propre fichier d'en-tête d'interface. Vous pouvez même aller plus loin si vous êtes sérieux au sujet du contenu:
//! The masked structure: the class byte_queue_t in the header file
typedef struct byte_queue_t {
uint8_t chMask [sizeof(struct {
uint32_t : 32;
uint16_t : 16;
uint16_t : 16;
uint16_t : 16;
uint16_t : 16;
})];
} byte_queue_t;
Remarque: Les extraits de code ci-dessus sont fournis pour illustrer le schéma sous-jacent mais ne sont pas pratiques, car l'alignement de la structure d'origine est manquant lors de la création du tableau de masque. Pour résoudre ce problème, vous devez extraire les informations d'alignement à l'aide de l'opérateur
__alignof__()et définir l'attribut d'alignement du tableau de masque en conséquence en utilisant__attribute__((aligned())).
PLOOC fournit la fonction "Private Protection" avec un schéma différent, plutôt que de s'appuyer sur le type de type. Cela lui permet de prendre en charge presque tous les compilateurs C avec les fonctionnalités C99 activées. En tant qu'auteur, je dois avouer qu'il a fallu beaucoup de temps pour comprendre comment gérer le type de type strict, et le schéma initial était à la fois laid et contre-intuitif. Grâce aux contributions inspirantes de Simon Qian, il a fallu encore trois mois pour affiner Plooc en quelque chose d'élégant et de simple. Le soutien d'Henry Long a également été crucial.
J'espère que vous apprécierez cette approche unique des défis de la programmation orientée objet dans C.
Si vous avez des questions ou des suggestions, n'hésitez pas à nous le faire savoir.
[08/25/2024] Correction du modèle de classe, version 4.6.4
Readme mis à jour
Ajouter __plooc_malloc_align() et __plooc_free
Ajouter private_method() , protected_method() et public_method()
Supprimer la dépendance des extensions GNU
Autres changements mineurs.
[11/02/2022] Correction du modèle de classe, version 4.6.3
[12/05/2022] Améliorer la compatibilité avec la dernière langue C ++, version 4.6.2
[02/01/2022] Ajouter des macros d'assistance pour le tas, version 4.6.1
__new_class() et __free_class() pour l'utilisation de Malloc et gratuitement avec les constructeurs et les destructeurs, c'est-à-dire xxxx_init () et xxxx_depose () .[30/12/2021] Amélioration du CMSIS-PAC, version 4.6.0
[29/12/2021] Ajouter CMSIS-PACK, version 4.5.9
[28/11/2020] Mise à jour mineure, version 4.5.7
[05/08/2020] Ajouter __PLOOC_CLASS_IMPlement__ et __Plooc_class_inherit__ version 4.5.6
[18/05/2020] Introduire à la fois un style court et long de macro, version 4.5.5
[16/05/2020] Mise à jour mineure, version 4.5.4a
[11/05/2020] Mise à jour mineure, version 4.5.4
[15/04/2020] MISE À JOUR __PLOOC_EVAL, version 4.5.3
[19/02/2020] Mise à jour mineure pour permettre l'optimisation de l'empreinte RAM, version 4.52
[21/01/2020] Mise à jour de Misc pour C90, version 4.51
[09/06/2019] Ajout de la prise en charge de C89 / 90, version 4.50
[09/05/2019] Ajout de la prise en charge de C89 / 90, version 4.40
[08/15/2019] PLOOC_CLASS_STRICT.H mis à jour pour utiliser plus de syntaxe pour adoucir, version 4.31
[08/14/2019] Prise en charge de la prise en charge limitée pour la surcharge, version 4.30
[07/26/2019] Syntaxe Update, version 4.21
[24/07/2019] Ajout d'un nouveau modèle de classe OOC, version 4.20
[07/12/2019] Mise à jour mineure, version 4.13
[05/30/2019] Mise à jour mineure, version 4.12
[05/02/2019] Efficacité Amélioration, version 4.11
[05/01/2019] Compatibilité Amélioration, version 4.04
[20/04/2019] Téléchargez Plooc sur GitHub, version 4.03
[17/04/2019] PLOOC téléchargé sur GitHub, version 4.01
La bibliothèque Plooc a été écrite par GorgonMeducer (王卓然） [email protected] et Simon Qian （钱晓晨） https://github.com/versaloon avec le soutien de Henry Long [email protected].
La bibliothèque Plooc est publiée sous une licence open source Apache 2.0 qui permet une utilisation commerciale et non commerciale sans restrictions. La seule exigence est que les crédits sont donnés dans le code source et dans la documentation de votre produit.
Le texte complet de la licence suit:
/*****************************************************************************
* Copyright(C)2009-2019 by GorgonMeducer<[email protected]> *
* and SimonQian<[email protected]> *
* with support from HenryLong<[email protected]> *
* *
* Licensed under the Apache License, Version 2.0 (the "License"); *
* you may not use this file except in compliance with the License. *
* You may obtain a copy of the License at *
* *
* http://www.apache.org/licenses/LICENSE-2.0 *
* *
* Unless required by applicable law or agreed to in writing, software *
* distributed under the License is distributed on an "AS IS" BASIS, *
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
* See the License for the specific language governing permissions and *
* limitations under the License. *
* *
****************************************************************************/
| module | Contrainteur |
|---|---|
| Plooc.h | Gorgonmeduner |
| Plooc_class.h | GorgonMeducer, Simon Qian |
| Plooc_class_strict.h | Gorgonmeduner |
| Plooc_class_back_box.h | Gorgonmeduner |
| Plooc_class_simple.h | Simon Qian |
| Plooc_class_simple_c90.h | Gorgonmeduner |
| module | Contrainteur |
|---|---|
| Comment définir une classe | Gorgonmeduner |
| Comment accéder aux membres protégés | Gorgonmeduner |
| Comment mettre en œuvre le polymorphisme | Gorgonmeduner |
Afin de montrer comment Plooc est facile et simple à utiliser, des exemples sont fournis pour démontrer différents aspects de la nouvelle méthode OOPC. Actuellement, les exemples disponibles sont:
Plus d'exemples seront ajoutés plus tard ...
Cet exemple montre
Comment implémenter une surcharge à l'aide de Plooc
Exiger le support C11
LOG_OUT("rn-[Demo of overload]------------------------------rn");
LOG_OUT((uint32_t) 0x12345678);
LOG_OUT("rn");
LOG_OUT(0x12345678);
LOG_OUT("rn");
LOG_OUT("PI is ");
LOG_OUT(3.1415926f);
LOG_OUT("rn");
LOG_OUT("rnShow BYTE Array:rn");
LOG_OUT((uint8_t *)main, 100);
LOG_OUT("rnShow Half-WORD Array:rn");
LOG_OUT((uint16_t *)main, 100/sizeof(uint16_t));
LOG_OUT("rnShow WORD Array:rn");
LOG_OUT((uint32_t *)main, 100/sizeof(uint32_t));
