PLOOC
v4.6.4 Minor Improvement
Programación protegida de objeto bajo de bajo nivel con ANSI-C, conocida como PLOOC ['PLU: K], es un conjunto de plantillas C bien pulidas C que:
Nota: Esta protección se puede deshabilitar definiendo la macro
__OOC_DEBUG__para facilitar la depuración.
_Generic .Nota: La sobrecarga es casi cero. La plantilla utiliza completamente las reglas de compilación aplicadas de ANSI-C para entregar características orientadas a objetos con un costo mínimo necesario.
- Suitable for both bare-metal and RTOS environments.
- Suitable for both 8-bit and 32-bit MCUs.
El concepto de C (OOC) orientado a objetos no es nuevo. Existen numerosas bibliotecas, SDK y plantillas que extienden ANSI-C con características de programación orientadas a objetos. Aunque PLOOC enfatiza su baja sobrecarga tanto en el tamaño del código como en el rendimiento, muchas soluciones OOC basadas en macro también ofrecen bajas sobrecargas. PLOOC no lo obliga a usar la gestión de la memoria del montón o la piscina, ni proporciona características de recolección de basura (GC), dejando estas opciones al usuario. Esto lo hace adecuado incluso para sistemas de 8 bits. Si bien algunos pueden ver esto como un inconveniente, es una opción de diseño deliberada. No discutiré sobre esto.
Entonces, ¿qué realmente distingue a PLOOC de los demás? ¿Es simplemente otra rueda reinventada?
La respuesta es no.
PLOOC presenta una característica única que carecen de la mayoría de las otras soluciones: asegura que los miembros privados de una clase sean verdaderamente privados y protegidos. Esto significa que los usuarios fuera del código fuente de clase pueden acceder a estos miembros privados. En cambio, solo ven un bloque sólido de memoria, enmascarado como una matriz de bytes. Dado que las clases en C se imitan por estructuras, PLOOC implementa clases utilizando una estructura enmascarada. Como se esperaba, solo el código fuente de clase puede acceder a los miembros privados, y solo el código fuente de clase de una clase derivada puede acceder a los miembros protegidos de la clase base. Los miembros públicos, sin embargo, son accesibles para todos.
¿Cómo funciona esto? Es posible que lo haya adivinado del término "estructura enmascarada". Esencialmente, es un truco de tallado de tipo en los archivos de encabezado.
Este truco funciona bien hasta que se encuentra con un compilador de verificación de tipo estricto. El ejemplo más famoso (o notable) es IAR, especialmente cuando el modo de compilación de múltiples archivos está habilitado. Ningún truco de tallado de tipo puede sobrevivir a las rigurosas controles del modo de compilación de múltiples archivos de 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;
Para que esto funcione, debe asegurarse de que el código fuente de clase no incluya su propio archivo de encabezado de interfaz. Incluso puedes ir más allá si te tomas en serio el contenido:
//! 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;
Nota: Los fragmentos de código anteriores se proporcionan para ilustrar el esquema subyacente, pero no son prácticos, ya que falta la alineación de la estructura original al crear la matriz de máscara. Para resolver esto, debe extraer la información de alineación utilizando el operador
__alignof__()y establecer el atributo de alineación de la matriz de máscara en consecuencia usando__attribute__((aligned())).
PLOOC proporciona la característica de "protección privada" con un esquema diferente, en lugar de depender del tallado de tipo. Esto le permite admitir casi todos los compiladores C con características C99 habilitadas. Como autor, debo confesar que tomó un tiempo considerable descubrir cómo lidiar con una verificación de tipo estricto, y el esquema inicial era feo y contradictorio. Gracias a las contribuciones inspiradoras de Simon Qian, tardó otros tres meses en refinar Plooc en algo elegante y simple. El apoyo de Henry Long también fue crucial.
Espero que disfrutes de este enfoque único para los desafíos de la programación orientada a objetos en C.
Si tiene alguna pregunta o sugerencia, no dude en informarnos.
[25/08/2024] FIJO plantilla de clase, versión 4.6.4
Readme actualizado
Agregar __plooc_malloc_align() y __plooc_free
Agregar private_method() , protected_method() y public_method()
Eliminar la dependencia de las extensiones de GNU
Otros cambios menores.
[02/11/2022] FIJO plantilla de clase, versión 4.6.3
[12/05/2022] Mejore la compatibilidad con el último lenguaje C ++, versión 4.6.2
[01/01/2022] Agregar macros auxiliar para el montón, versión 4.6.1
__new_class() y __free_class() para usar malloc y gratis junto con constructores y destructores, es decir, xxxx_init () y xxxx_depose () .[30/12/2021] CMSIS-PAC mejorado, versión 4.6.0
[29/12/2021] Agregar paquete CMSIS, versión 4.5.9
[28/11/2020] Actualización menor, versión 4.5.7
[05/08/2020] Agregar __PLOOC_CLASS_IMPLEMENT__ y __PLOOC_CLASS_INHERIT__ Versión 4.5.6
[18/05/2020] Introducir al estilo de macro corto y largo, versión 4.5.5
[16/05/2020] Actualización menor, versión 4.5.4a
[11/05/2020] Actualización menor, versión 4.5.4
[15/04/2020] Actualización __PLOOC_EVAL, versión 4.5.3
[19/02/2020] Actualización menor para habilitar la optimización de huellas de RAM, versión 4.52
[21/01/2020] Actualización misceláneas para C90, versión 4.51
[06/06/2019] Se agregó soporte para C89/90, versión 4.50
[09/05/2019] Se agregó soporte para C89/90, versión 4.40
[15/08/2019] actualizado PLOOC_CLASS_STRICT.H para usar más sintaxis de suavizar, versión 4.31
[14/08/2019] introdujo soporte para soporte limitado para sobrecarga, versión 4.30
[26/07/2019] Actualización de sintaxis, versión 4.21
[24/07/2019] Se agregó una nueva plantilla de clase OOC, versión 4.20
[12/07/2019] Actualización menor, versión 4.13
[30/05/2019] Actualización menor, versión 4.12
[05/02/2019] Mejora de eficiencia, versión 4.11
[05/01/2019] Mejora de compatibilidad, versión 4.04
[20/04/2019] Sube PLOOC a GitHub, versión 4.03
[17/04/2019] Plooc cargado a GitHub, versión 4.01
La Biblioteca PLOOC fue escrita por GorgonMeducer (王卓然） 王卓然） 王卓然） 王卓然） 王卓然） 王卓然） 王卓然） 王卓然） 王卓然） 王卓然） 王卓然） 王卓然） 王卓然） 王卓然）[email protected] y Simon Qian （钱晓晨） https://github.com/versaloon con apoyo de Henry Long [email protected].
La biblioteca PLOOC se lanza bajo una licencia de código abierto Apache 2.0 que permite el uso comercial y no comercial sin restricciones. El único requisito es que los créditos se otorgan en el código fuente y en la documentación de su producto.
Sigue el texto completo de la licencia:
/*****************************************************************************
* 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. *
* *
****************************************************************************/
| módulo | Artilizante |
|---|---|
| plooc.h | Gorgonmetucer |
| plooc_class.h | Gorgonmeducer, Simon Qian |
| plooc_class_strict.h | Gorgonmetucer |
| plooc_class_back_box.h | Gorgonmetucer |
| plooc_class_simple.h | Simon Qian |
| plooc_class_simple_c90.h | Gorgonmetucer |
| módulo | Artilizante |
|---|---|
| Cómo definir una clase | Gorgonmetucer |
| Cómo acceder a los miembros protegidos | Gorgonmetucer |
| Cómo implementar el polimorfismo | Gorgonmetucer |
Para mostrar cómo PLOOC es fácil y simple de usar, se proporcionan ejemplos para demostrar diferentes aspectos del nuevo método OOPC. Actualmente, los ejemplos disponibles son:
Se agregarán más ejemplos más tarde ...
Este ejemplo muestra
Cómo implementar la sobrecarga utilizando PLOOC
Requiere soporte 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));
