Guía de estilo de Google en C ++. Parte 10

Formateo

Longitud de la línea

• . , URL-, 80 .
• /, 80 . , .
• include.
• using

-ASCII

Espacios contra pestañas

Declaraciones de funciones y definiciones

ReturnType ClassName::FunctionName(Type par_name1, Type par_name2) {
  DoSomething();
  ...
}

ReturnType ClassName::ReallyLongFunctionName(Type par_name1, Type par_name2,
                                             Type par_name3) {
  DoSomething();
  ...
}

ReturnType LongClassName::ReallyReallyReallyLongFunctionName(
    Type par_name1,  //  4 
    Type par_name2,
    Type par_name3) {
  DoSomething();  //  2 
  ...
}

• Elige buenos nombres para las opciones.
• Puede omitir el nombre del parámetro si no se usa en la definición de la función.
• , , . .
• .
• .
• .
• . .
• , , .
• .
• .
• — 2 .
• Al transferir parámetros a otra línea, sangra 4 espacios.

class Foo {
 public:
  Foo(const Foo&) = delete;
  Foo& operator=(const Foo&) = delete;
};

class Shape {
 public:
  virtual void Rotate(double radians) = 0;
};

class Circle : public Shape {
 public:
  void Rotate(double radians) override;
};

void Circle::Rotate(double /*radians*/) {}

//   -  -     ,
//    .
void Circle::Rotate(double) {}

ABSL_MUST_USE_RESULT bool IsOk();

Lambdas

int x = 0;
auto x_plus_n = [&x](int n) -> int { return x + n; }

std::set<int> blacklist = {7, 8, 9};
std::vector<int> digits = {3, 9, 1, 8, 4, 7, 1};
digits.erase(std::remove_if(digits.begin(), digits.end(), [&blacklist](int i) {
               return blacklist.find(i) != blacklist.end();
             }),
             digits.end());

Números de punto flotante

float f = 1.f;
long double ld = -.5L;
double d = 1248e6;

float f = 1.0f;
float f2 = 1;   //  
long double ld = -0.5L;
double d = 1248.0e6;

Llamada de función

bool result = DoSomething(argument1, argument2, argument3);

bool result = DoSomething(averyveryveryverylongargument1,
                          argument2, argument3);

if (...) {
  ...
  ...
  if (...) {
    bool result = DoSomething(
        argument1, argument2,  //  4 
        argument3, argument4);
    ...
  }

int my_heuristic = scores[x] * y + bases[x];
bool result = DoSomething(my_heuristic, x, y, z);

bool result = DoSomething(scores[x] * y + bases[x],  //  
                          x, y, z);

//     3x3
my_widget.Transform(x1, x2, x3,
                    y1, y2, y3,
                    z1, z2, z3);

Formatear una lista de inicialización

//      .
return {foo, bar};
functioncall({foo, bar});
std::pair<int, int> p{foo, bar};

//     .
SomeFunction(
    {"assume a zero-length name before {"},
    some_other_function_parameter);
SomeType variable{
    some, other, values,
    {"assume a zero-length name before {"},
    SomeOtherType{
        "Very long string requiring the surrounding breaks.",
        some, other values},
    SomeOtherType{"Slightly shorter string",
                  some, other, values}};
SomeType variable{
    "This is too long to fit all in one line"};
MyType m = {  // Here, you could also break before {.
    superlongvariablename1,
    superlongvariablename2,
    {short, interior, list},
    {interiorwrappinglist,
     interiorwrappinglist2}};

Condiciones

if (condition) {  //    
  ...  //  2 
} else if (...) {  // 'else'      
  ...
} else {
  ...
}

if ( condition ) {  //   
  ...  //  2 
} else {  // 'else'      
  ...
}

if(condition) {   //  -    'if'
if (condition){   //  -    {
if(condition){    //  

if (condition) {  //   -     'if'   {

if (x == kFoo) return new Foo();
if (x == kBar) return new Bar();

//  -    ,   'else'
if (x) DoThis();
else DoThat();

if (condition)
  DoSomething();  //  2 

if (condition) {
  DoSomething();  //  2 
}

//  -    'if',  'else' - 
if (condition) {
  foo;
} else
  bar;

//  -    'else',  'if' - 
if (condition)
  foo;
else {
  bar;
}

//  -     'if'   'else'
if (condition) {
  foo;
} else {
  bar;
}

Bucles e interruptores

switch (var) {
  case 0: {  //  2 
    ...      //  4 
    break;
  }
  case 1: {
    ...
    break;
  }
  default: {
    assert(false);
  }
}

switch (x) {
  case 41:  //  
  case 43:
    if (dont_be_picky) {
      //    ( )    
      ABSL_FALLTHROUGH_INTENDED;
    } else {
      CloseButNoCigar();
      break;
    }
  case 42:
    DoSomethingSpecial();
    ABSL_FALLTHROUGH_INTENDED;
  default:
    DoSomethingGeneric();
    break;
}

for (int i = 0; i < kSomeNumber; ++i)
  printf("I love you\n");

for (int i = 0; i < kSomeNumber; ++i) {
  printf("I take it back\n");
}

while (condition) {
  //    false
}
for (int i = 0; i < kSomeNumber; ++i) {}  // .      -   
while (condition) continue;  //  - continue     

while (condition);  //  -     do/while

Punteros y enlaces

x = *p;
p = &x;
x = r.y;
x = r->y;

• '.' y '->' se usan sin espacios.
• Los operadores * o & no están separados por espacios.

// ,   *, &
char *c;
const std::string &str;

// ,   *, &
char* c;
const std::string& str;

//  - 
int x, y;

int x, *y;  //  -      &  *
char * c;  //  -     *
const std::string & str;  //  -     &

Expresiones lógicas

if (this_one_thing > this_other_thing &&
    a_third_thing == a_fourth_thing &&
    yet_another && last_one) {
  ...
}

Valores de retorno

return result;                  //   -  
//  - .    
return (some_long_condition &&
        another_condition);

return (value);                // . ,      var = (value);
return(result);                // . return -   !

Inicializar variables y matrices

int x = 3;
int x(3);
int x{3};
std::string name = "Some Name";
std::string name("Some Name");
std::string name{"Some Name"};

std::vector<int> v(100, 1);  //    
std::vector<int> v{100, 1};  //   2- : 100  1

int pi(3.14);  // : pi == 3
int pi{3.14};  //  : "" 

Directivas del pre procesador

//  -    
  if (lopsided_score) {
#if DISASTER_PENDING      //  -    
    DropEverything();
# if NOTIFY               //   # - ,   
    NotifyClient();
# endif
#endif
    BackToNormal();
  }

//  -   
  if (lopsided_score) {
    #if DISASTER_PENDING  // ! "#if"     
    DropEverything();
    #endif                // !     "#endif"
    BackToNormal();
  }

Formato de clase

class MyClass : public OtherClass {
 public:      //  1 
  MyClass();  //  2-  
  explicit MyClass(int var);
  ~MyClass() {}

  void SomeFunction();
  void SomeFunctionThatDoesNothing() {
  }

  void set_some_var(int var) { some_var_ = var; }
  int some_var() const { return some_var_; }

 private:
  bool SomeInternalFunction();

  int some_var_;
  int some_other_var_;
};

• El nombre de la clase base se escribe en la misma línea que el nombre de la clase heredada (por supuesto, teniendo en cuenta el límite de 80 caracteres).
• Palabras clave del público: , protegidas ,: y privadas: deben tener una sangría de un espacio.
• Cada una de estas palabras clave debe ir precedida de una línea en blanco (con la excepción de la primera mención). Además, en clases pequeñas, se pueden omitir líneas en blanco.
• No agregue una línea en blanco después de estas palabras clave.
• La sección pública debe ser la primera, detrás de ella protegida y al final la sección privada .
• Vea el Procedimiento de Declaración para construir declaraciones en cada una de estas secciones.

Listas de inicialización de constructor

//    
MyClass::MyClass(int var) : some_var_(var) {
  DoSomething();
}

//          ,
//           
MyClass::MyClass(int var)
    : some_var_(var), some_other_var_(var + 1) {
  DoSomething();
}

//     ,     
//     
MyClass::MyClass(int var)
    : some_var_(var),             //  4 
      some_other_var_(var + 1) {  //   
  DoSomething();
}

//     ,       
MyClass::MyClass(int var)
    : some_var_(var) {}

Formateo de espacios de nombres

namespace {

void foo() {  // .   
  ...
}

}  // namespace

namespace {

  // .   ,   
  void foo() {
    ...
  }

}  // namespace

namespace foo {
namespace bar {

Desglose horizontal

Principios generales

void f(bool b) {  //       
  ...
int i = 0;  //       
//            .
//    ,      
int x[] = { 0 };
int x[] = {0};

//        
class Foo : public Bar {
 public:
  //  inline-  
  //     (  )
  Foo(int b) : Bar(), baz_(b) {}  //    
  void Reset() { baz_ = 0; }  //      
  ...

Ciclos y condiciones

if (b) {          //        
} else {          //   else
}
while (test) {}   //       
switch (i) {
for (int i = 0; i < 5; ++i) {
//         .   .
//   ,  
switch ( i ) {
if ( test ) {
for ( int i = 0; i < 5; ++i ) {
//         
//          ,   
for ( ; i < 5 ; ++i) {
  ...

//           
for (auto x : counts) {
  ...
}
switch (i) {
  case 1:         //    case  
    ...
  case 2: break;  //    ,   (   )  

Operadores

//     
x = 0;

//      ,
//   /   .
//          
v = w * x + y / z;
v = w*x + y/z;
v = w * (x + z);

//       
x = -5;
++x;
if (x && !y)
  ...

Patrones y moldes

//       (<  >),
//  <,  >(  
std::vector<std::string> x;
y = static_cast<char*>(x);

//        .       
std::vector<char *> x;

Desglose vertical

• Una línea vacía al principio o al final de una función no mejorará la legibilidad.
• Las líneas vacías en la cadena de bloques if-else pueden mejorar la legibilidad.
• Una línea vacía frente a la línea de comentarios generalmente ayuda a la legibilidad del código; un nuevo comentario generalmente implica la finalización de un pensamiento antiguo y el comienzo de una nueva idea. Y la línea vacía claramente lo insinúa.