C++ 最佳实践 | 2. 代码风格

struct Size{  int width;  int height;
  Size(int t_width, int t_height) : width(t_width), height(t_height) {}};
// This version might make sense for thread safety or something,// but more to the point, sometimes we need to hide data, sometimes we don't.class PrivateSize{  public:    int width() const { return m_width; }    int height() const { return m_height; }    PrivateSize(int t_width, int t_height) : m_width(t_width), m_height(t_height) {}
  private:    int m_width;    int m_height;};

class MyClass{public:  MyClass(int t_data)    : m_data(t_data)  {  }
  int getData() const  {    return m_data;  }
private:  int m_data;};

// this function does somethingint myFunc(){}

/*// this function does somethingint myFunc(){}*/

#ifndef MYPROJECT_MYCLASS_HPP#define MYPROJECT_MYCLASS_HPP
namespace MyProject {  class MyClass {  };}
#endif

// Bad Idea// This compiles and does what you want, but can lead to confusing// errors if modification are made in the future and close attention// is not paid.for (int i = 0; i < 15; ++i)  std::cout << i << std::endl;
// Bad Idea// The cout is not part of the loop in this case even though it appears to be.int sum = 0;for (int i = 0; i < 15; ++i)  ++sum;  std::cout << i << std::endl;

// Good Idea// It's clear which statements are part of the loop (or if block, or whatever).int sum = 0;for (int i = 0; i < 15; ++i) {  ++sum;  std::cout << i << std::endl;}

// Bad Idea// hard to followif (x && y && myFunctionThatReturnsBool() && caseNumber3 && (15 > 12 || 2 < 3)) {}
// Good Idea// Logical grouping, easier to readif (x && y && myFunctionThatReturnsBool()    && caseNumber3    && (15 > 12 || 2 < 3)) {}

// Bad Idea. Requires extra -I directives to the compiler// and goes against standards.#include <string>#include <includes/MyHeader.hpp>
// Worse Idea// Requires potentially even more specific -I directives and// makes code more difficult to package and distribute.#include <string>#include <MyHeader.hpp>

// Good Idea// Requires no extra params and notifies the user that the file// is a local file.#include <string>#include "MyHeader.hpp"

// Bad Ideaclass MyClass{public:  MyClass(int t_value)  {    m_value = t_value;  }
private:  int m_value;};
// Bad Idea// This leads to an additional constructor call for m_myOtherClass// before the assignment.class MyClass{public:  MyClass(MyOtherClass t_myOtherClass)  {    m_myOtherClass = t_myOtherClass;  }
private:  MyOtherClass m_myOtherClass;};
// Good Idea// There is no performance gain here but the code is cleaner.class MyClass{public:  MyClass(int t_value)    : m_value(t_value)  {  }
private:  int m_value;};
// Good Idea// The default constructor for m_myOtherClass is never called here, so // there is a performance gain if MyOtherClass is not is_trivially_default_constructible. class MyClass{public:  MyClass(MyOtherClass t_myOtherClass)    : m_myOtherClass(t_myOtherClass)  {  }
private:  MyOtherClass m_myOtherClass;};

// ... //private:  int m_value = 0; // allowed  unsigned m_value_2 = -1; // narrowing from signed to unsigned allowed// ... //

// Best Idea
// ... //private:  int m_value{ 0 }; // allowed  unsigned m_value_2 { -1 }; // narrowing from signed to unsigned not allowed, leads to a compile time error// ... //

class MyClass{public:  MyClass(int t_value)    : m_value{t_value}  {  }
private:  const int m_value{0};};

std::vector<int> v1{2,3,4,5,6,7,8,9};std::vector<int> v2{9,8,7,6,5,4,3,2,1};const auto s1 = v1.size();const auto s2 = v2.size();const auto diff = s1 - s2; // diff underflows to a very large number

assert(registerSomeThing()); // make sure that registerSomeThing() returns true

//bad ideastruct S {  operator int() {    return 2;  }};
//good ideastruct S {  explicit operator int() {    return 2;  }};