Quais são as convenções de nomenclatura típicas para funções públicas e privadas do OO C? [fechadas]

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 
}

A convenção que uso é:

• Função pública (no arquivo de cabeçalho):

  struct Classname;
  Classname_functionname(struct Classname * me, other args...);
  

• Função privada (estática no arquivo de implementação)

  static functionname(struct Classname * me, other args...)

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.

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.

Se existe uma "classe" real, na forma de uma estrutura, tipo opaco ou similar, então o nomeio de acordo com:

typedef struct classname_t classname_t; 

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()ou app_construct(), o "destructor app_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.