Qt Coding Style/es

Spanish English Русский 日本語 [toc align_right="yes" depth="2"]

Guia de estilo de código Qt

Este es un resumen de las practicas de codificación que usamos al escribir el código de Qt.

Los datos han sido recogidos de diferentes fuentes relacionas con Qt, foros de discusión, discusiones de correo electrónico y mediante la colaboración de los desarrolladores.

Sangrado (Indentación)

• Usar 4 espacios para sangrar
• Espacios, no tabulaciones!

Declarando variables

• Declarar cada variable en una linea separada
• Evitar nombres cortos siempre que sea posible (ej. "a", "rbarr", "nughdeget")
• Se recomiendan nombres de variables de un solo caracter solamente para usar en contadores y dónde el propósito de la variable es obvio.
• Esperar hasta que sea necesario para declarar una variable

 // Incorrecto
 int a, b;
 char *c, *d;

// Correcto
 int height;
 int width;
 char *nameOfThis;
 char '''nameOfThat;

El nombre de las variables y las funciones comienza con una letra minúsculas. Las siguientes palabras en el nombre de la variable empiezan con una letra mayúscula.

• Evitar la abreviaturas

 // Incorrecto
 short Cntr;
 char ITEM_DELIM = '';

// Correcto
 short counter;
 char itemDelimiter = '';

• Los nombres de las Clases siempre comienzan con una letra mayuscular. Clases publicas comienzan con una 'Q' (QRgb). Las funciones publicas a menudo comienzan con una 'q' (qRgb).

Espacios en blanco

• Usar lineas en blanco para agrupar declaraciones
• Siempre usar una linea en blanco
• Siempre usar un espacio en blanco despues de un carácter, y antes de un corchete

 // Incorrecto
 if(foo){
 }

// Correcto
 if (foo) {
 }

• Para punteros o referencias, siempre usar un espacio en blanco entre el o '&', pero no usarlos entre o '&' y el nombre de la variable

 char '''x;
 const QString &myString;
 const char''' const y = "hello";

• Envuelva los operadores binarios con espacios
• Ningún espacio después de un "cast"
• Evitar los "cast" como en C, en la medida de lo posible

 // Incorrecto
 char* blockOfMemory = (char* ) malloc(data.size());

// Correcto
 char '''blockOfMemory = reinterpret_cast<char'''>(malloc(data.size()));

Llaves

• Como regla básica, el corchete izquierdo debe estar en la misma linea de inicio de la declaración:

 // Incorrecto
 if (codec)
 {
 }

// Correcto
 if (codec) {
 }

• Las implementaciones de funciones y las declaraciones de clase siempre tendrán el corchete izquierdo en una nueva línea:

 static void foo(int g)
 {
 qDebug("foo: %i", g);
 }

class Moo
 {
 };

• Usar llaves cuando el cuerpo de una declaración condicional contenga mas de una linea, y también si una declaración de una simple linea es algo compleja.

 // 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: Use llaves a si la declaración padre abarca muchas lineas

 // Correcto
 if (address.isEmpty() || !isValid()
 || !codec) {
 return false;
 }

• Excepción 2: Use llaves también en bloques if-then-else, donde el código 'if' o el código 'else' ocupen varias lineas.

 // Incorrecto
 if (address.isEmpty())
 return false;
 else {
 qDebug("%s", qPrintable(address));
it;
 }

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

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

 // Correcto
 if (a) {
 if (b)
 …
 else
 …
 }

• Use llaves cuando el cuerpo de una sentencia condicional este vacía

 // Incorrecto
 while (a);

 // Correcto
 while (a) {}

h2. Paréntesis

• Use paréntesis para agrupar expresiones:

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

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

 // Incorrecto
 a'' b & c

// Correcto
 (a + b) & c

Declaraciones Switch

• El case debe estar en la misma columna que el switch
• Cada declaración case debe tener un break (o return) al final o un comentario que indique porque intencionalmente no hay un break

 switch (myEnum) {
 case Value1:
 doSomething();
 break;
 case Value2:
 doSomethingElse();
 // fall through
 default:
 defaultHandling();
 break;
 }

Saltos de linea

• Limite el largo de las lineas a 100 caracteres, inserte saltos de linea si son necesarios

• Las comas van al final de una línea quebrada, los operadores deben empezar al principio de la nueva línea. Un operador al final de la línea no es fácil de ver si el editor es demasiado estrecho.

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

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

Herencia y la keyword `virtual`

• Cuando reimplemente un método virtual, no ponga la keyword `virtual` en el archivo header.