Pergunta curta
Existe uma maneira típica de nomear membros 'públicos' e 'privados' de um projeto OO C?
Antecedentes
Entendo perfeitamente que os membros públicos e privados não existem realmente na linguagem C. No entanto, como a maioria dos programadores em C, eu ainda trato os membros como públicos ou privados para manter o design do OO. Além dos métodos típicos de OO, encontrei-me seguindo um padrão (veja o exemplo abaixo) que facilita para mim distinguir quais métodos se destinam ao mundo exterior versus os membros privados que podem ter menos verificações / são mais eficientes etc. ... Existe uma norma ou prática recomendada para tal coisa ou o meu exemplo abaixo é uma boa maneira de abordar isso?
Cabeçalho de exemplo
#ifndef _MODULE_X_H_
#define _MODULE_X_H_
bool MOD_X_get_variable_x(void);
void MOD_X_set_variable_x(bool);
#endif /* _MODULE_X_H_ */
Fonte de exemplo
// Module Identifier: MOD_X
#include "module_x.h"
// Private prototypes
static void mod_x_do_something_cool(void);
static void mod_x_do_something_else_cool(void);
// Private Variables
static bool var_x;
// Public Functions - Note the upper case module identifier
bool MOD_X_get_variable_x(void) {return var_x;}
void MOD_X_set_variable_x(bool input){var_x = input;}
// Private Functions - Note the lower case module identifier
void mod_x_do_something_cool(void){
// Some incredibly cool sub routine
}
void mod_x_do_something_else_cool(void){
// Another incredibly cool sub routine
}
fonte
Respostas:
A convenção que uso é:
Função pública (no arquivo de cabeçalho):
Função privada (estática no arquivo de implementação)
Não se concentre no caso. O objetivo é distinguir dois métodos públicos de duas classes, acrescentando um prefixo (nome da classe nesta convenção).
Além disso, o que torna OO-C é a maneira como o objeto é passado como primeiro argumento.
fonte
Normalmente, a convenção é não colocar as funções privadas no cabeçalho .
Como você normalmente coloca a implementação de um objeto totalmente em uma fonte, a função privada geralmente pode ser apenas estática no arquivo. Nesse caso, você costuma pular o prefixo para salvar algumas digitações (o símbolo não estará visível fora dessa unidade de compilação).
Se, por algum motivo, você precisar disponibilizar a função para alguma outra classe, mas ainda assim privada, você o nomeará como qualquer outro método, mas coloque-o em um cabeçalho "-private" separado.
O mesmo se aplica à definição do tipo também. Se possível, você apenas declara a estrutura como tipo incompleto no cabeçalho e define-a na fonte ou no cabeçalho "-private". Você precisa da definição para herdar a classe, portanto, trataria o cabeçalho extra como protegido e não como material particular.
Provavelmente, o maior pedaço de código orientado a objetos em C é a plataforma Gnome. Você pode ver com mais facilidade a convenção na biblioteca GObject, que fornece as classes base de nível mais baixo . É basicamente o que eu descrevi acima e é usado em todo o Gnome.
fonte
Se existe uma "classe" real, na forma de uma estrutura, tipo opaco ou similar, então o nomeio de acordo com:
O sufixo _t é uma convenção de nomenclatura muito comum em C, usada pelo próprio padrão C. Menos comum é usar uma letra maiúscula para classes / tipos.
A próxima coisa que você faz é criar um prefixo de nomenclatura para todas as funções públicas. Normalmente, algo com três letras. Talvez todas as funções pertencentes à "classe apple" sejam nomeadas
app_set_something()
,app_get_something()
etc.Então você vai querer usar uma convenção de nomenclatura consistente. O "construtor" pode ser nomeado
app_init()
ouapp_construct()
, o "destructorapp_clear()
,app_destruct()
,app_destroy()
ou similar. Use a mesma convenção de nomenclatura para todas as suas classes. Em seguida, faça o mesmo para funções setter / getter, e assim por diante.Funções privadas (estáticas) realmente não precisam de um prefixo de classe, pois não são acessíveis fora do arquivo .c. Você ainda pode dar a eles o mesmo prefixo por motivos de consistência, ou talvez simplesmente nomeá-los todos com um prefixo particular, como
private_func()
. Uma maneira muito comum é dar nomes a eles começando com um sublinhado, mas isso é ruim, pois pode colidir com as funções da biblioteca. A rigor, você não tem permissão para usar identificadores começando com um sublinhado.Eu não recomendaria usar maiúsculas como uma maneira de distinguir entre privado e público. A convenção em quase todos os padrões de codificação C é que todas as letras maiúsculas indicam uma constante, macro ou um pré-processador definido. Essa convenção é usada pelo próprio padrão C, pela API do Windows, pelo kernel do Linux e assim por diante.
fonte