tutorial smart remix programador online español curso c++ coding-style

c++ - smart - Pautas para mejorar su código



smart contracts ethereum (22)

C # Normas de codificación y convenciones de nomenclatura

A continuación están nuestros estándares de codificación de C #, convenciones de nomenclatura y mejores prácticas. Úselos en sus propios proyectos y / o ajústelos a sus propias necesidades.

Nombrar Convenciones y Estilo

utilice PascalCasing para nombres de clase y métodos.

Por qué: coherente con el .NET Framework de Microsoft y fácil de leer.

use camelCasing para argumentos de método y variables locales.

Por qué: coherente con el .NET Framework de Microsoft y fácil de leer.

no utilizar : utilizar notación húngara o cualquier otra identificación de tipo en los identificadores

Por qué: en consonancia con .NET Framework y Visual Studio IDE de Microsoft, la determinación de tipos es muy sencilla (mediante la información sobre herramientas). En general, desea evitar los indicadores de tipo en cualquier identificador.

no use Screaming Caps para constantes o variables de solo lectura

Lea más en "C # Coding Standards and Naming Conventions" con ejemplo aquí

¿Qué pautas sigues para mejorar la calidad general de tu código? Muchas personas tienen reglas sobre cómo escribir código C ++ que (supuestamente) hacen que sea más difícil cometer errores. He visto personas insisten en que cada instrucción if es seguida por un bloque de llaves ( {...} ).

Me interesan las pautas que siguen otras personas y las razones que las respaldan. También me interesan las pautas que piensas que son basura, pero que son comunes. ¿Alguien puede sugerir algunos?

Para empezar, mencionaré algunos para comenzar:

  • Siempre use llaves después de cada declaración if / else (mencionada anteriormente). El razonamiento detrás de esto es que no siempre es fácil saber si una sola declaración es en realidad una declaración, o una macro de preprocesador que se expande a más de una declaración, por lo que este código se romperá:

// top of file: #define statement doSomething(); doSomethingElse // in implementation: if (somecondition) doSomething();

pero si usa llaves, funcionará como se espera.

  • Use las macros del preprocesador SOLAMENTE para la compilación condicional. las macros de preprocesador pueden causar todo tipo de infierno, ya que no permiten las reglas de exploración de C ++. Me he encallado muchas veces debido a las macros del preprocesador con nombres comunes en los archivos de encabezado. ¡Si no tienes cuidado, puedes causar todo tipo de estragos!

Ahora a ti.

  1. Eliminar código innecesario

Eso es todo.

  1. Use un formato consistente.
  2. Cuando trabaje en código heredado, emplee el estilo de formateo existente, esp. estilo de refuerzo.
  3. Obtenga una copia del libro de Scott Meyer Effective C ++
  4. Obtenga una copia del libro completo de Steve MConnell.
  1. configurar la convención de codificación y hacer que todos los involucrados sigan la convención (no querría leer código que requiera que adivine dónde está la siguiente declaración / expresión porque no está sangrada correctamente)
  2. constantemente refactorizando su código (obtenga una copia de Refactoring, por Martin Fowler, los pros y los contras se detallan en el libro)
  3. escribir un código débilmente acoplado (evitar escribir comentarios escribiendo código autoexplicativo, el código débilmente acoplado tiende a ser más fácil de administrar / adaptar al cambio)
  4. si es posible, prueba tu código en una unidad (o si eres lo suficientemente macho, TDD).
  5. Libertad anticipada, la liberación a menudo
  6. evitar la optimización prematura (el perfilado ayuda a optimizar)

Active todas las advertencias que pueda soportar en su compilador (gcc: "La -Wall es un buen comienzo pero no incluye todo, así que verifique los documentos") y haga que se conviertan en errores (gcc: -Werror ).

Algunos de mis favoritos personales:

Esfuércese por escribir un código que sea const correcto . Alistarás el compilador para que te ayude a eliminarlo, pero a veces son bugs muy dolorosos. Tu código también contará una historia de lo que tenías en mente en el momento en que lo escribiste: valioso para los recién llegados o mantenedores una vez que te hayas ido.

Salga del negocio de gestión de memoria. Aprenda a usar punteros inteligentes: std::auto_ptr , std::tr1::shared_ptr (o boost::shared_ptr ) y boost::scoped_ptr . Conozca las diferencias entre ellos y cuándo usar uno frente a otro.

Probablemente va a utilizar la biblioteca de plantillas estándar. Lee el libro de Josuttis . No se detenga después de los primeros capítulos en contenedores pensando que conoce el STL. Presiona a lo bueno: algoritmos y objetos de función.

Asegúrate de sangrar adecuadamente

En if las declaraciones ponen la constante en la izquierda, es decir,

if( 12 == var )

no

if( var == 12 )

Porque si te olvidas de escribir un ''='', entonces se convierte en asignación. En la versión superior, el compilador dice que esto no es posible, en el último se ejecuta y el if es siempre verdadero.

Utilizo llaves para si siempre que no estén en la misma línea.

if( a == b ) something(); if( b == d ) { bigLongStringOfStuffThatWontFitOnASingleLineNeatly(); }

Las llaves abiertas y cerradas siempre tienen sus propias líneas. Pero eso es, por supuesto, una convención personal.

Solo comenten cuando solo sea necesario explicar qué está haciendo el código, donde leer el código no podría decir lo mismo.

No comente ningún código que ya no esté usando. Si desea recuperar el código anterior, use su sistema de control de origen. Comentar el código simplemente hace que las cosas se vean desordenadas, y hace que sus comentarios que realmente son importantes se desvanezcan en el desorden de fondo del código comentado.

  • Use y haga cumplir un estilo de codificación y pautas comunes. Justificación: cada desarrollador en el equipo o en la empresa puede leer el código sin distracciones que puedan ocurrir debido a diferentes estilos de corsés o similares.
  • Haga una reconstrucción completa de su base de origen completa (es decir, realice compilaciones o creaciones diarias después de cada registro) e informe cualquier error. Justificación: la fuente casi siempre está en un estado utilizable, y los problemas se detectan poco después de que se "implementan", donde la resolución de problemas es barata.

  • Use pestañas para las sangrías, pero alinee los datos con los espacios Esto significa que las personas pueden decidir cuánto sangrar cambiando el tamaño de las pestañas, pero también que las cosas permanezcan alineadas (por ejemplo, puede querer todo el ''='' en una línea vertical cuando asigne valores a estructura)

  • Siempre usa constantes o funciones en línea en lugar de macros donde sea posible

  • Nunca use ''using'' en los archivos de encabezado, porque todo lo que incluye ese heafer también se verá afectado, incluso si la persona que incluye su encabezado no quiere todos los std (por ejemplo) en su espacio de nombres global.

  • Si algo es más largo que unos 80 columes, divídalo en múltiples líneas, por ejemplo

    if(SomeVeryLongVaribleName != LongFunction(AnotherVarible, AString) && BigVaribleIsValid(SomeVeryLongVaribleName)) { DoSomething(); }

  • Solo sobrecargar a los operadores para que hagan lo que espera el usuario, por ejemplo, sobrecargar los operadores + y - para un 2dVector está bien

  • Siempre comente su código, incluso si es solo para decir lo que está haciendo el siguiente bloque (por ejemplo, "eliminar todas las texturas que no son necesarias para este nivel"). Es posible que alguien necesite trabajar más tarde, posiblemente después de que se haya ido y no quiera encontrar miles de líneas de código sin comentarios que indiquen qué hace qué.

Hmm - Probablemente debería haber sido un poco más específico.

No estoy buscando mucho consejo para mí mismo: estoy escribiendo una herramienta de análisis de código estático (las ofertas comerciales actuales no son lo suficientemente buenas para lo que quiero), y estoy buscando ideas para complementos para resaltar posibles errores en el código.

Varias personas han mencionado cosas como const correctness y el uso de punteros inteligentes: ese es el tipo de pensamiento que puedo verificar. La comprobación de indentación y comentarios es un poco más difícil de hacer (desde un punto de vista de programación de todos modos).

La guía de estilo de Google, mencionada en una de estas respuestas, es bastante sólida. Hay algunas cosas inútiles, pero es más bueno que malo.

Sutter y Alexandrescu escribieron un libro decente sobre este tema, llamado C ++ Coding Standards .

Aquí hay algunos consejos generales de lil ''ole me:

  1. Su estilo de sangría y horquillado son incorrectos. Lo mismo ocurre con los demás. Así que sigue los estándares del proyecto para esto. Trate su orgullo y configure su editor para que todo sea lo más constante posible con el resto de la base de código. Es realmente molesto tener que leer el código sangrado de forma irregular. Dicho esto, el horquillado y la sangría no tienen nada que ver con "mejorar tu código". Se trata más de mejorar tu habilidad para trabajar con otros.

  2. Comenta bien Esto es extremadamente subjetivo, pero en general siempre es bueno escribir comentarios sobre por qué el código funciona de la manera en que lo hace, en lugar de explicar lo que hace. Por supuesto, para código complejo también es bueno para los programadores que no estén familiarizados con el algoritmo o el código tener una idea de lo que está haciendo también. Los enlaces a las descripciones de los algoritmos empleados son muy bienvenidos.

  3. Exprese la lógica de la manera más directa posible. Irónicamente, las sugerencias como "poner constantes en el lado izquierdo de las comparaciones" han salido mal aquí, creo. Son muy populares, pero para los que hablan inglés, a menudo rompen el flujo lógico del programa con los que leen. Si no puedes confiar en ti mismo (o en tu compilador) para escribir la igualdad se compara correctamente, entonces usa trucos como este. Pero sacrificas la claridad cuando lo haces. También caer dentro de esta categoría son cosas como ... "¿Mi lógica tiene 3 niveles de sangrado? ¿Podría ser más simple?" e implementar un código similar en funciones. Tal vez incluso dividiendo funciones. Se requiere experiencia para escribir código que exprese elegantemente la lógica subyacente, pero vale la pena trabajar en ello.

Esos fueron bastante generales. Para consejos específicos, no puedo hacer un trabajo mucho mejor que Sutter y Alexandrescu.

También hay una buena Guía de estilo de C ++ utilizada internamente por Google, que incluye la mayoría de las reglas mencionadas aquí.

Comience a escribir muchos comentarios, pero use eso como una oportunidad para refactorizar el código para que se explique por sí mismo.

es decir:

for(int i=0; i<=arr.length; i++) { arr[i].conf() //confirm that every username doesn''t contain invalid characters }

Debería haber sido algo más como

for(int i=0; i<=activeusers.length; i++) { activeusers[i].UsernameStripInvalidChars() }

Donde pueda, use el preincremento en lugar del incremento posterior.

Utilizo PC-Lint en mis proyectos de C ++ y, especialmente, cómo hace referencia a publicaciones existentes, como las directrices MISRA o "Effective C ++" de Scott Meyers y "C ++ más eficaz". Incluso si planea escribir justificaciones muy detalladas para cada regla que verifique su herramienta de análisis estático, es una buena idea señalar las publicaciones establecidas en las que confía su usuario.

Este es el consejo más importante que me dio un gurú de C ++, y me ayudó en algunas ocasiones críticas a encontrar errores en mi código:

  • Use métodos const cuando un método no debe modificar el objeto.
  • Use referencias y punteros const en parámetros cuando el objeto no debe modificar el objeto.

Con estas 2 reglas, el compilador te dirá de forma gratuita en qué parte de tu código la lógica es defectuosa.

Míralo seis meses después

Los indicadores inteligentes tienen una buena forma de indicar la propiedad con mucha claridad. Si eres una clase o una función:

  • si obtienes un puntero sin formato , no tienes nada. Se le permite usar la punta, cortesía de su interlocutor, quien garantiza que la punta permanecerá viva más tiempo que usted.
  • si obtienes un weak_ptr , no tienes el pointee y, además, el pointee puede desaparecer en cualquier momento.
  • si obtiene un shared_ptr , posee el objeto junto con otros, por lo que no debe preocuparse. Menos estrés, pero también menos control.
  • si obtiene un auto_ptr , usted es el único propietario del objeto. Es tuyo, eres el rey. Usted tiene el poder de destruir ese objeto, o dárselo a otra persona (perdiendo así la propiedad).

Creo que el caso de auto_ptr es especialmente fuerte: en un diseño, si veo un auto_ptr, inmediatamente sé que ese objeto va a "vagar" de una parte del sistema a la otra.

Esta es al menos la lógica que uso en mi proyecto favorito. No estoy seguro de cuántas variaciones puede haber sobre el tema, pero hasta ahora este conjunto de reglas me ha sido útil.