C ++ में Google स्टाइल गाइड। भाग १०

का प्रारूपण

रेखा लंबाई

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

-ASCII

रिक्त स्थान बनाम टैब

समारोह की घोषणाएँ और परिभाषाएँ

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

• विकल्पों के लिए अच्छे नाम चुनें।
• यदि आप फ़ंक्शन की परिभाषा में इसका उपयोग नहीं किया गया है, तो आप पैरामीटर नाम को छोड़ सकते हैं।
• , , . .
• .
• .
• .
• . .
• , , .
• .
• .
• — 2 .
• जब मापदंडों को दूसरी पंक्ति में स्थानांतरित किया जाता है, तो 4 रिक्त स्थान पर इंडेंट करें।

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

दशमलव संख्याएं

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;

फंक्शन कॉल

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

एक प्रारंभिक सूची तैयार करना

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

शर्तेँ

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

लूप और स्विच

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

संकेत और लिंक

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

• '।' और '->' का उपयोग रिक्त स्थान के बिना किया जाता है।
• * या & ऑपरेटर रिक्त स्थान से अलग नहीं होते हैं।

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

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

//  - 
int x, y;

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

तार्किक भाव

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

मान लौटाएं

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

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

वैरिएबल्स और एरर्स को आरम्भ करना

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

प्रीप्रोसेसर निर्देश

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

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

कक्षा स्वरूपण

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

• बेस क्लास का नाम उसी लाइन पर लिखा गया है जिसका नाम विरासत में मिला वर्ग (निश्चित रूप से, 80% की सीमा को ध्यान में रखते हुए) है।
• कुंजी शब्द सार्वजनिक: , संरक्षित ,: , और निजी: एक अंतरिक्ष इंडेंट किया जाना चाहिए।
• इनमें से प्रत्येक कीवर्ड को एक रिक्त पंक्ति (पहले उल्लेख के अपवाद के साथ) से पहले होना चाहिए। साथ ही, छोटी कक्षाओं में, खाली लाइनों को छोड़ा जा सकता है।
• इन कीवर्ड के बाद ब्लैंक लाइन न जोड़ें।
• सार्वजनिक अनुभाग पहले होना चाहिए, इसके पीछे संरक्षित और अंत में निजी अनुभाग ।
• इनमें से प्रत्येक अनुभाग में घोषणाओं के निर्माण के लिए घोषणा प्रक्रिया देखें।

कंस्ट्रक्टर प्रारंभिक सूची

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

स्वरूपण नामस्थान

namespace {

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

}  // namespace

namespace {

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

}  // namespace

namespace foo {
namespace bar {

क्षैतिज विखंडन

सामान्य सिद्धांत

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

चक्र और स्थितियाँ

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

ऑपरेटर्स

//     
x = 0;

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

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

पैटर्न और कास्ट

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

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

कार्यक्षेत्र का टूटना

• शुरुआत में या किसी समारोह के अंत में एक खाली लाइन पठनीयता में सुधार नहीं करेगी।
• अगर-और ब्लॉकचेन में खाली लाइनें पठनीयता में सुधार कर सकती हैं।
• टिप्पणी लाइन के सामने एक खाली लाइन आमतौर पर कोड की पठनीयता में मदद करती है - एक नई टिप्पणी में आमतौर पर एक पुराने विचार का पूरा होना और एक नए विचार की शुरुआत शामिल है। और खाली रेखा उस पर स्पष्ट रूप से इशारा कर रही है।