Qt Coding Style/es

From Qt Wiki
Jump to: navigation, search

En Ar Bg De El Es Fa Fi Fr Hi Hu It Ja Kn Ko Ms Nl Pl Pt Ru Sq Th Tr Uk Zh

Esta es una revisión a bajo nivel de las convenciones de escritura de programación utilizando Qt. Ir a Coding Conventions para las convenciones de alto nivel.

Los datos han sido recopilados desde las fuentes de Qt, foros de discusión, discusiones por email y a través de colaboraciones de los desarrolladores.

Indentación

  • 4 espacios por indentación
  • Espacios, no tabs!

Declaración de variables

  • Declarar cada variable en una línea distinta
  • Evitar nombres sin sentido y cortos (ejemplo: "a", "rbarr", "nughdeget")
  • Nombres de variables de solo un carácter serán aceptado solo para contadores y variables temporales, donde el propósito de la variable es obvio
  • Solo declarar una variable hasta cuando será utilizada
 // Incorrecto
 int a, b;
 char *c, *d;

 // Correcto
 int height;
 int width;
 char *nameOfThis;
 char *nameOfThat;
  • Variables y funciones comienzan con una letra minúscula. Cada palabra consecutiva en el nombre de la variable comienza con una letra mayúscula
  • Evitar abreviaciones
 // Incorrecto
 short Cntr;
 char ITEM_DELIM = ' ';

 // Correcto
 short counter;
 char itemDelimiter = ' ';
  • Las clases siempre comienzan con mayúscula. Las clases públicas comienzan con una 'Q' (QRgb) seguida de una letra en mayúscula. Las funciones públicas habitualmente comienzan con una 'q' (qRgb).
  • Los acrónimos utilizan camel-case (ejemplo: QXmlStreamReader, no QXMLStreamReader).

Espacios en blanco

  • Utilizar líneas vacías para agrupar declaraciones relacionadas
  • Siempre utilizar solo una línea vacía
  • Siempre utilizar un espacio en blanco despues de una palabra clave y antes de un paréntesis redondo:
 // Incorrecto
 if(foo){
 }

 // Correcto
 if (foo) {
 }
  • Para punteros o referencias, siempre utilizar un solo espacio en blano entre el tipo y el '*' o '&', pero sin espacios entre '*' o '&' y el nombre de la variable:
 char *x;
 const QString &myString;
 const char * const y = "hola";
  • Rodear operadores binarios con espacios
  • No utilizar espacios despues de un cast
  • Evitar cast con estilo de "C" cuando es posible
 // Incorrecto
 char* blockOfMemory = (char* ) malloc(data.size());

 // Correct
 char *blockOfMemory = reinterpret_cast<char *>(malloc(data.size()));
  • No escribir multiples declaraciones en una línea
  • Por extensión, utilizar una nueva línea para el cuerpo de una declaración de flujo de control:
 // Incorrecto
 if (foo) bar();

 // Correct
 if (foo)
     bar();

Paréntesis

  • Utilizar llaves adjuntas: La llave the abre va en la misma línea que la declaración. Si la llave que cierra es seguida por otra palabra clave, se incluye en la misma línea:
 // Incorrecto
 if (codec)
 {
 }
 else
 {
 }

 // Correcto
 if (codec) {
 } else {
 }
  • Excepción: Las implementaciones de funciones (no lambdas) y las declaraciones de clases siempre deben tener la llave izquierda al comienzo de una línea:
 static void foo(int g)
 {
     qDebug("foo: %i", g);
 }

 class Moo
 {
 };
  • Utilizar paréntesis de llave solo cuando el cuerpo de una declaración de condición contiene mas de una línea:
 // Incorrecto
 if (address.isEmpty()) {
     return false;
 }

 for (int i = 0; i < 10; ++i) {
     qDebug("%i", i);
 }

 // Correcto
 if (address.isEmpty())
     return false;

 for (int i = 0; i < 10; ++i)
     qDebug("%i", i);
  • Excepción 1: Utilizar paréntesis también si la declaración padre cubre varias líneas:
 // Correcto
 if (address.isEmpty() || !isValid()
     || !codec) {
     return false;
 }
  • Excepción 2: Simetria de paréntesis: Utilizar paréntesis también en bloques if-then-else
donde el código de if o de else considera varias líneas:
 // Incorrecto
 if (address.isEmpty())
     qDebug("empty!");
 else {
     qDebug("%s", qPrintable(address));
     it;
 }

 // Correcto
 if (address.isEmpty()) {
     qDebug("empty!");
 } else {
     qDebug("%s", qPrintable(address));
     it;
 }

 // Incorrecto
 if (a)
     ...
 else
     if (b)
         ...

 // Correcto
 if (a) {
     ...
 } else {
     if (b)
         ...
 }
  • Utilizar parentesis de llave cuando el cuerpo de la declaración de un condicional está vacío.
 // Incorrecto
 while (a);

 // Correcto
 while (a) {}

Paréntesis

  • Utilizar paréntesis para agrupar expresiones:
 // Incorrecto
 if (a && b || c)

 // Correcto
 if ((a && b) || c)

 // Incorrecto
 a + b & c

 // Correcto
 (a + b) & c

Declaración de Switch

  • Las etiquetas case deben estar en la misma columna que el switch
  • Cada case debe tener un break (o return) al final o utilizar Q_FALLTHROUGH() para indicar que no hay intencionalmente un break, a menos que otro case comience inmediatamente
 switch (myEnum) {
 case Value1:
   doSomething();
   break;
 case Value2:
 case Value3:
   doSomethingElse();
   Q_FALLTHROUGH();
 default:
   defaultHandling();
   break;
 }

Declaración de saltos (break, continue, return, y goto)

  • No escribir 'else' despues de declaraciones de salto:
 // Incorrecto
 if (thisOrThat)
     return;
 else
     somethingElse();

 // Correcto
 if (thisOrThat)
     return;
 somethingElse();
  • Excepción: Si el código simétrico, el uso de'else' está permitido para visualizar dicha simetria.

Quiebres de línea

  • Mantener líneas con menos de 100 caracteres; el quebrado es posible si es necesario
    • Líneas de comentarios/apidoc deben tener menos de 80 columnas de texto. Adjustar a los alrededores, e intentar continuar el flujo del texto para evitar párrafos "jagged".
  • Las comas van al final de las líneas quebradas; los operadores comienzan al inicio de las líneas nuevas. Un operador al final de la línea es fácil de ignorar si el editor es muy estrecho.
 // Incorrecto
 if (longExpression +
     otherLongExpression +
     otherOtherLongExpression) {
 }

 // Correcto
 if (longExpression
     + otherLongExpression
     + otherOtherLongExpression) {
 }

Excepciones generales

  • Cuando se siga alguna regla y haga que el código se vea mal, existe total libertad para romper dicha regla

Estilo artístico

El siguiente 'snippet' puede utilizarse para darle un nuevo formato artístico al código:
--style=kr 
--indent=spaces=4 
--align-pointer=name 
--align-reference=name 
--convert-tabs 
--attach-namespaces
--max-code-length=100 
--max-instatement-indent=120 
--pad-header
--pad-oper

Notar que "unlimited" --max-instatement-indent es utilizado solo porque astyle no es suficientemente inteligente para agrupar el primer argumento si las líneas siguientes necesitan limitaciones de indentación. Se le recomienda limitar manualmente in-statement-indent a aproximadamente 50 columnas:

    int foo = some_really_long_function_name(and_another_one_to_drive_the_point_home(
            first_argument, second_argument, third_arugment));