tipos - Normas de codificación para C puro(no C++)

tipos de codificacion de texto

Question

Vengo de un fondo en java (de mis clases de CS) y un semestre de C ++. Estoy terminando un proyecto OpenCV para mi Co-Op que está en C pura, por lo que me demoro en hacer esta pregunta.

¿Cuáles son los procesos de diseño y estándares de codificación para C puro?

Estoy familiarizado con la programación orientada a objetos, el diseño y las mejores prácticas. Estoy un poco perdido en un lenguaje no orientado a objetos como C. Cada variable y función parece ser global. Me hace sentir como un verdadero desastre.

Answer 1

Es posible que desee echar un buen vistazo a la fuente del Kernel de Linux ... Por cierto, no es el código más fácil para comenzar, pero dado que proviene de un fondo de programación, puede ayudar ... Como objeto Como programador orientado, es posible que encuentre que el manejo de errores en C es una tarea cuesta arriba. Puede ser que esto ayude ---> http://www.freetype.org/david/reliable-c.html

Answer 2

Es posible que le interese consultar las respuestas a una pregunta similar que hice hace poco. Además, si está interesado en las guías de estilo C, puede echar un vistazo a esta página, ya que es un repositorio para las guías de estilo C (y C ++). Si tiene ganas de reírse , eche un vistazo a la Guía de estilo C de la NASA . En particular, eche un vistazo al comentario masivo ... sabrá de cuál estoy hablando. No escribas comentarios como este por favor.

Personalmente recomiendo la guía de estilo Indian Hill C con algunas modificaciones. Además, es posible que desee comprar el libro C Interfaces e Implementaciones si tiene problemas para diseñar programas a gran escala en C.

Answer 3

La buena noticia es que puede programar en forma semi-orientada a objetos en C. Puede proteger datos, exponer funciones de acceso, etc. Es posible que no tenga toda la fantasía de C ++, sino por lo que he visto del código C ++ de otras personas. , muchas personas no usan la fantasía de todos modos. En otras palabras, las personas escriben el código C dentro de una clase, donde en C escribirían el mismo código sin el contenedor de la clase.

Primero, lea un libro sobre programación y estilo en C, K&R está bien. En segundo lugar, recomendaría revisar el estándar de programación CERT . Aunque este sitio se centra principalmente en los estándares de codificación "seguros", gran parte del contenido aquí son estándares generales de calidad del código que todos deben seguir. Hacer lo mencionado aquí mejorará su calidad, eliminará molestos errores y, como efecto secundario, hará que su código sea más seguro.

Answer 4

Puede hacer que el alcance de una función u objeto sea local a su archivo de origen declarándolo "estático". Eso ayuda un poco.

De lo contrario, el lenguaje típico que veo para evitar choques de espacio de nombres es poner algún tipo de identificador de instalación en el nombre. Por ejemplo, todo en foo.c podría llamarse foo_ *

Answer 5

Puede hacer un diseño orientado a objetos en C pura. Un enfoque fácil es pensar en un módulo como una class con métodos públicos como funciones ordinarias que requieren que this parámetro sea un primer argumento explícito.

Es útil si el nombre de la class es un prefijo en el nombre de la función, y si todas las funciones privadas y los datos de la clase se declaran static . Construye constructores con malloc() para obtener la memoria y la inicialización explícita de los campos de datos.

Un constructor para un objeto con miembros de datos totalmente privados puede exponer un puntero opaco (tipeado void * even, o como un puntero a un tipo incompleto si se desea el tipo de seguridad). Si desea tener solo miembros de datos públicos, entonces un puntero a una struct definida públicamente funciona bien.

Este patrón es seguido por una serie de bibliotecas. Una función de inicialización devuelve una cookie que debe devolverse a todos los métodos de la biblioteca, y un método sirve como destructor.

Por supuesto, hay otras formas de diseñar bien en C pura, pero si OO funciona para usted, no tiene que abandonarlo por completo.

Answer 6

Puede restringir la visibilidad de las variables y funciones de alcance de archivo a sus respectivos archivos de origen (aunque eso no le impide pasar punteros a estos objetos).

Por ejemplo:

/** foo.c */
static void foo_helper() {...} /* foo_helper cannot be called by name 
                                  outside of foo.c */
static int local_state;        /* local state is visible at file scope,
                                  but is not exported to the linker */

Answer 7

Sinceramente, no creo que ninguna de las respuestas en le enseñe a diseñar y escribir programas en C bien estructurados. Necesitas leer un buen libro, y el más obvio para leer es The C Programming Language de Kernighan & Ritchie.

Answer 8

Trabaja con otros buenos programadores de C Tener un código de revisión con ellos. No solo dejen que miren su código, sino que también miran su código.

Answer 9

No tengo experiencia profesional en C (solo en C ++), así que no tome mis consejos, trucos y consejos demasiado en serio, ya que están "orientados a objetos".

Casi objeto C?

La simulación de características básicas similares a objetos se puede hacer fácilmente:

En el encabezado, declare hacia adelante su tipo, teclee la definición y declare los "métodos". Por ejemplo:

/* MyString.h */

#include <string.h>

/* Forward declaration */
struct StructMyString ;

/* Typedef of forward-declaration (note: Not possible in C++) */
typedef struct StructMyString MyString ;

MyString *       MyString_new() ;
MyString *       MyString_create(const char * p_pString) ;
void             MyString_delete(MyString * p_pThis) ;
size_t           MyString_length(const MyString * p_pThis) ;

MyString *       MyString_copy(MyString * p_pThis, const MyString * p_pSource) ;
MyString *       MyString_concat(MyString * p_pThis, const MyString * p_pSource) ;

const char *     MyString_get_c_string(const MyString * p_pThis) ;
MyString *       MyString_copy_c_string(MyString * p_pThis, const char * p_pSource) ;
MyString *       MyString_concat_c_string(MyString * p_pThis, const char * p_pSource) ;

Verás que cada función tiene prefijo. Elijo el nombre de la "estructura" para asegurarme de que no habrá colisión con otro código.

Verás, también, que usé "p_pThis" para seguir con la idea de OO.

En el archivo fuente, defina su tipo y defina las funciones:

/* MyString.c */

#include "MyString.h"

#include <string.h>
#include <stdlib.h>

struct StructMyString
{
   char *      m_pString ;
   size_t      m_iSize ;
} ;

MyString * MyString_new()
{
   MyString * pMyString = malloc(sizeof(MyString)) ;

   pMyString->m_iSize = 0 ;
   pMyString->m_pString = malloc((pMyString->m_iSize + 1) * sizeof(char)) ;
   pMyString->m_pString[0] = 0 ;

   return pMyString ;
}

/* etc. */

Si desea funciones "privadas" (o variables globales privadas), declararlas estáticas en la fuente C. De esta manera, no serán visibles afuera:

static void doSomethingPrivate()
{
   /* etc. */
}

static int g_iMyPrivateCounter = 0 ;

Si quieres herencia, entonces estás casi jodido. Si creía que todo en C era global, incluida la variable, debería obtener más experiencia en C incluso antes de intentar pensar cómo podría simularse la herencia.

Misceláneo Consejos

Evitar múltiples rutas de código.

Por ejemplo, los rendimientos múltiples son arriesgados. Por ejemplo:

void doSomething(int i)
{
   void * p = malloc(25) ;

   if(i > 0)
   {
      /* this will leak memory ! */
      return ;
   }

   free(p) ;
}

Evita los globulares no constantes.

Esto incluye variables "estáticas" (que no son funciones estáticas).

Las variables globales que no son constantes son casi siempre una mala idea (es decir, consulte C strtok API para ver un ejemplo de la función de mierda), y si se produce un código seguro de multiproceso, es una tarea difícil de manejar.

Evitar la colisión de nombres

Elija un "espacio de nombres" para sus funciones y para sus definiciones. Esto podría ser:

#define GROOVY_LIB_x_MY_CONST_INT 42

void GroovyLib_dosomething() ;

Cuidate define

Las definiciones no se pueden evitar en C, ¡pero pueden tener efectos secundarios!

#define MAX(a, b) (a > b) ? (a) : (b)

void doSomething()
{
   int i = 0, j = 1, k ;
   k = MAX(i, j) ;   /* now, k == 1, i == 0 and j == 1 */
   k = MAX(i, j++) ; /* now, k == 2, i == 0 and j == 3, NOT 2, and NOT 1 !!! */
}

Inicializa tus variables

Evita declarar variables sin inicializarlas:

int i = 42 ; /* now i = 42 */
int j ;      /* now j can have any value */
double k ;   /* now f can have any value, including invalid ones ! */

Las variables no inicializadas son las causas de los insectos dolorosos.

Conoce toda la API de C

La lista de funciones de la API C como se describe en K&R es bastante pequeña. Leerás la lista completa en 20 minutos. Debes conocer esas funciones.

¿Quieres algo de experiencia?

Reescriba la API de C. Por ejemplo, intente escribir su propia versión de las funciones string.h para ver cómo se hace.