Directrices de codificación en C++

Mejores prácticas

1. NUNCA incluir declaraciones using namespace en archivos de encabezado.

2. NUNCA incluir una declaración de uso para el espacio de nombres estándar (std). En su lugar, calificar siempre todos los tipos provenientes de él.

3. UTILIZAR una expresión constexpr en lugar de una MACRO siempre que sea posible.

4. UTILIZAR pragma once en lugar de guardias de encabezado.

5. UTILIZAR enum class en lugar de enum siempre que sea posible.

6. SIEMPRE declarar variables lo más cerca posible de su primer uso, ¡esto no es C!

7. SIEMPRE pasar parámetros no triviales por referencia.

8. PREFERIR un valor de retorno compuesto (por ejemplo, pair, struct POD) a múltiples parámetros de salida.

9. PREFERIR auto siempre que sea posible, pero usar tantos modificadores de tipo (const, volatile, &, *) como sea posible.

10. EVITAR volatile a menos que haya una justificación muy fuerte (generalmente no la hay).

11. SIEMPRE utilizar declaraciones using en lugar de typedef para alias.

12. UTILIZAR calificadores de función (override, final, const) libremente.

13. PREFERIR una enumeración a múltiples booleanos.

14. UTILIZAR espacios de nombres anónimos con libertad en archivos cpp y exportar el número mínimo de nombres desde cada objeto de compilación.

15. NUNCA utilizar funciones libres estáticas.

Estructura de archivos / directorios

Si un archivo cpp/h contiene una sola clase, el archivo debe tener el nombre de la clase y estar en UpperCamelCase. Si un archivo cpp/h contiene funciones de utilidad, el archivo debe tener un nombre descriptivo y estar en UpperCamelCase.

Esperamos jerarquías paralelas de directorios de código fuente y pruebas. Por ejemplo,

root
- parser  # package name, directory containing source code
  Parser.h/cpp  # contains class Parser
  - ast
    - Ast.h/cpp  # contains various exports

- tests  # directory containing tests for source code
  - ParserTests.cpp  # unit tests for parser/Parser.h/cpp
  - ast
    - AstTests.cpp  # unit tests for parser/ast/Ast.h/cpp

Denominación

1. Las funciones estáticas y libres deben ser UpperCamelCase

2. Los nombres de las funciones miembro deben ser minúsculasCamelCase

3. Las constantes (globales o locales) deben ser Upper_Camel_Case.

4. #defines debe ser TITLE_CASE

5. Las variables locales y los parámetros de función deben ser lowerCamelCase

6. Los miembros de la estructura deben ser UpperCamelCase

Incluye

1. Utilice siempre “/” en incluye y NUNCA “\”, (estándar C WG14/N1256 punto 6.4.7, estándar C++ ISO/IEC 14882:2003 punto 2.8, estándar C++ ISO/IEC 14882:2011 (del borrador de trabajo N3225) punto 2.9)

2. Intente incluir la cantidad mínima de archivos necesarios para una compilación exitosa. Corolario: no incluyas nada que no necesites.

3. El orden incluye desde lo más específico hasta lo más general.

Estilo

for (auto&& pEntity : entities) {
    singleEntityVector[0] = pEntity;
    auto result = dispatcher.dispatch(m_config.ValidationPolicy, singleEntityVector);
    m_config.pObserver->notify(*pEntity, observerContext);
}

BITXORCORE_LOG(debug) << "comparing chain scores: " << localScore << " (local) vs "
        << remoteScore << " (remote)";
return pState
        && pState->ImportanceInfo.Importance > Importance(0)
        && pState->Balances.get(Xem_Id) >= minHarvestingBalance;

// mind the double indent for method arguments
thread::future<std::unique_ptr<model::Block>> BlockAt(
        Height height,
        const io::BlockStorageView& storage) {
    if (Height(0) == height || storage.chainHeight() < height) {
        auto exception = CreateHeightException("unable to get block at height", height);
        return thread::make_exceptional_future<std::unique_ptr<model::Block>>(exception);
    }

    return thread::make_ready_future(storage.loadBlock(height));
}

Foo() : m_value(0)
{}

// two indents
Foo(very arguments, much wow)
        : m_value(0)
        , m_xman(professor)
{}

Foo() : m_value(0) {
    // body
}

// two indents
Foo(very arguments, much wow)
        : m_value(0)
        , m_xman(professor) {
    // body
}