PLOOC
v4.6.4 Minor Improvement
A programação protegida de objetos de baixa cabeçalho com ANSI-C, conhecida como PLOOC ['PLU: K], é um conjunto de modelos de macro C bem polidos que:
NOTA: Essa proteção pode ser desativada, definindo a macro
__OOC_DEBUG__para facilitar a depuração.
_Generic .Nota: A sobrecarga é quase zero. O modelo utiliza totalmente as regras de compilação forçadas da ANSI-C para fornecer recursos orientados a objetos com um custo mínimo necessário.
- Suitable for both bare-metal and RTOS environments.
- Suitable for both 8-bit and 32-bit MCUs.
O conceito de C (OOC) orientado a objetos não é novo. Existem inúmeras bibliotecas, SDKs e modelos que estendem o ANSI-C com os recursos de programação orientados a objetos. Embora a Plooc enfatize sua baixa sobrecarga no tamanho e no desempenho do código, muitas soluções OOC baseadas em macro também oferecem baixa sobrecarga. O Plooc não forçá você a usar o gerenciamento de memória de heap ou pool, nem fornece recursos de coleta de lixo (GC), deixando essas opções para o usuário. Isso o torna adequado até para sistemas de 8 bits. Embora alguns possam ver isso como uma desvantagem, é uma opção de design deliberada. Não vou discutir sobre isso.
Então, o que realmente diferencia o Plooc dos outros? É simplesmente outra roda reinventada?
A resposta é não.
A PLOOC apresenta um recurso exclusivo que a maioria das outras soluções não possui: garante que os membros privados de uma classe sejam realmente privados e protegidos. Isso significa que os usuários fora do código -fonte da classe são impedidos de acessar esses membros privados. Em vez disso, eles vêem apenas um bloco sólido de memória, mascarado como uma matriz de bytes. Como as classes em C são imitadas por estruturas, o Plooc implementa classes usando uma estrutura mascarada. Como esperado, apenas o código -fonte da classe pode acessar os membros privados e apenas o código -fonte da classe de uma classe derivada pode acessar os membros protegidos da classe base. Os membros públicos, no entanto, são acessíveis a todos.
Como é que isso funciona? Você deve ter adivinhado a partir do termo "estrutura mascarada". Essencialmente, é um truque de truque de tipo nos arquivos de cabeçalho.
Esse truque funciona bem até encontrar um compilador rigoroso de verificação de tipo. O exemplo mais famoso (ou notório) é o IAR, especialmente quando o modo de compilação de vários arquivos está ativado. Nenhum truque de tração de tipo pode sobreviver às verificações rigorosas do modo de compilação de vários arquivos da 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 fazer isso funcionar, você deve garantir que o código -fonte da classe não inclua seu próprio arquivo de cabeçalho de interface. Você pode até ir mais longe se levar a sério o conteúdo:
//! 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: Os trechos de código acima são fornecidos para ilustrar o esquema subjacente, mas não são práticos, pois o alinhamento da estrutura original está faltando ao criar a matriz de máscara. Para resolver isso, você precisa extrair as informações de alinhamento usando o operador
__alignof__()e definir o atributo de alinhamento da matriz de máscara de acordo com__attribute__((aligned())).
O PLOOC fornece o recurso "Proteção privada" com um esquema diferente, em vez de depender da tração do tipo. Isso permite suportar quase todos os compiladores C com os recursos C99 ativados. Como autor, devo confessar que demorou um tempo considerável para descobrir como lidar com a verificação rigorosa do tipo, e o esquema inicial era feio e contra-intuitivo. Graças às contribuições inspiradoras de Simon Qian, levou mais três meses para refinar o PLOOC em algo elegante e simples. O apoio de Henry Long também foi crucial.
Espero que você goste dessa abordagem única para os desafios da programação orientada a objetos em C.
Se você tiver alguma dúvida ou sugestão, sinta -se à vontade para nos informar.
[25/08/2024] Modelo de classe Fix, versão 4.6.4
Readme atualizado
Adicionar __plooc_malloc_align() e __plooc_free
Adicione private_method() , protected_method() e public_method()
Remova a dependência das extensões GNU
Outras pequenas mudanças.
[11/02/2022] Modelo de classe Fix, versão 4.6.3
[12/05/2022] Melhore a compatibilidade com a mais recente linguagem C ++, versão 4.6.2
[01/02/2022] Adicione macros auxiliares para heap, versão 4.6.1
__new_class() e __free_class() para usar Malloc e gratuitamente junto com construtores e destruidores, ou seja, xxxx_init () e xxxx_depose () .[30/12/2021] CMSIS-PAC aprimorado, versão 4.6.0
[29/12/2021] Adicione cmsis-pack, versão 4.5.9
[28/11/2020] Atualização menor, versão 4.5.7
[05/08/2020] Adicione __plooc_class_implement__ e __plooc_class_inherit__ versão 4.5.6
[18/05/2020] Apresente o estilo de macro curto e longo, versão 4.5.5
[16/05/2020] Atualização menor, versão 4.5.4a
[11/05/2020] Atualização menor, versão 4.5.4
[15/04/2020] ATUALIZAÇÃO __PLOOC_EVAL, versão 4.5.3
[19/02/2020] Atualização menor para ativar a otimização da pegada RAM, versão 4.52
[21/01/2020] ATUALIZAÇÃO MISC para C90, versão 4.51
[09/06/2019] Adicionado suporte para C89/90, versão 4.50
[05/09/2019] Adicionado suporte para C89/90, versão 4.40
[15/08/2019] atualizado Plooc_Class_Strict.h para usar mais sintaxe suavizada, versão 4.31
[14/08/2019] Introduziu o suporte para suporte limitado para sobrecarga, versão 4.30
[26/07/2019] Atualização de sintaxe, versão 4.21
[24/07/2019] Adicionado novo modelo de classe OOC, versão 4.20
[07/12/2019] Atualização menor, versão 4.13
[30/05/2019] Atualização menor, versão 4.12
[05/02/2019] Melhorar a eficiência, versão 4.11
[05/05/2019] Melhoria da compatibilidade, versão 4.04
[20/04/2019] Carregar o Plooc para o GitHub, versão 4.03
[17/04/2019] Carregado Plooc para o GitHub, versão 4.01
The PLOOC library was written by GorgonMeducer(王卓然）[email protected] and Simon Qian（钱晓晨）https://github.com/versaloon with support from Henry Long [email protected].
A biblioteca Plooc é liberada sob uma licença de código aberto Apache 2.0 que permite o uso comercial e não comercial sem restrições. O único requisito é que os créditos são fornecidos no código -fonte e na documentação do seu produto.
O texto completo da licença segue:
/*****************************************************************************
* 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 | Contrinuador |
|---|---|
| Plooc.h | Gorgonmeduces |
| Plooc_class.h | Gorgonmeduces, Simon Qian |
| PLOOC_CLASS_STRITT.H | Gorgonmeduces |
| Plooc_class_back_box.h | Gorgonmeduces |
| Plooc_class_simple.h | Simon Qian |
| PLOOC_CLASS_SIMPLE_C90.H | Gorgonmeduces |
| módulo | Contrinuador |
|---|---|
| Como definir uma aula | Gorgonmeduces |
| Como acessar membros protegidos | Gorgonmeduces |
| Como implementar o polimorfismo | Gorgonmeduces |
Para mostrar como o Plooc é fácil e simples de usar, são fornecidos exemplos para demonstrar diferentes aspectos do novo método OOPC. Atualmente, os exemplos disponíveis são:
Mais exemplos serão adicionados mais tarde ...
Este exemplo mostra
Como implementar sobrecarga usando Plooc
Requer suporte 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));
