Google Style Guide in C ++. Teil 10

Formatierung

Linienlänge

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

-ASCII

Leerzeichen gegen Tabulatoren

Funktionsdeklarationen und Definitionen

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 
  ...
}

• Wählen Sie gute Namen für Optionen.
• Sie können den Parameternamen weglassen, wenn er nicht in der Funktionsdefinition verwendet wird.
• , , . .
• .
• .
• .
• . .
• , , .
• .
• .
• — 2 .
• Wenn Sie Parameter in eine andere Zeile übertragen, rücken Sie 4 Leerzeichen ein.

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());

Gleitkommazahlen

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;

Funktionsaufruf

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);

Formatieren einer Initialisierungsliste

//      .
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}};

Bedingungen

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;
}

Schleifen und Schalter

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

Zeiger und Links

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

• '.' und '->' werden ohne Leerzeichen verwendet.
• Die Operatoren * oder & werden nicht durch Leerzeichen getrennt.

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

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

//  - 
int x, y;

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

Logische Ausdrücke

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

Rückgabewerte

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

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

Variablen und Arrays initialisieren

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};  //  : "" 

Präprozessor-Direktiven

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

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

Klassenformatierung

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_;
};

• Der Name der Basisklasse wird in dieselbe Zeile geschrieben wie der Name der geerbten Klasse (natürlich unter Berücksichtigung der Beschränkung auf 80 Zeichen).
• Schlüsselwörter: public : , protected,: und private: sollten um ein Leerzeichen eingerückt werden.
• Vor jedem dieser Schlüsselwörter muss eine Leerzeile stehen (mit Ausnahme der ersten Erwähnung). In kleinen Klassen können auch Leerzeilen weggelassen werden.
• Fügen Sie nach diesen Schlüsselwörtern keine Leerzeile ein.
• Der öffentliche Bereich sollte der erste sein, dahinter geschützt und am Ende der private Bereich .
• Informationen zum Erstellen von Deklarationen finden Sie in jedem dieser Abschnitte unter Deklarationsverfahren.

Konstruktorinitialisierungslisten

//    
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) {}

Namespaces formatieren

namespace {

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

}  // namespace

namespace {

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

}  // namespace

namespace foo {
namespace bar {

Horizontale Aufteilung

Allgemeine Grundsätze

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; }  //      
  ...

Zyklen und Bedingungen

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;  //    ,   (   )  

Betreiber

//     
x = 0;

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

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

Muster und Abgüsse

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

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

Vertikale Aufteilung

• Eine leere Zeile am Anfang oder am Ende einer Funktion verbessert die Lesbarkeit nicht.
• Leere Zeilen in der if-else-Blockchain können die Lesbarkeit verbessern.
• Eine leere Zeile vor der Kommentarzeile verbessert normalerweise die Lesbarkeit des Codes. Ein neuer Kommentar beinhaltet normalerweise die Vervollständigung eines alten Gedankens und den Beginn einer neuen Idee. Und die leere Zeile deutet deutlich darauf hin.