콘월 이층집

guide

Google C++ Style Guide 정리하기 - Naming

반응형

Naming

명명(naming) 및 주석(comment)을 포함한 모든 코드에서 포괄적인 언어를 사용하고 다른 프로그래머가 무례하거나 불쾌하다고 생각할 수 있는 용어는 사용하지 않는다.

  • such as "master" and "slave", "blacklist" and "whitelist", or "redline”

마찬가지로, 특정 사람을 언급하지 않는 한 중립적인 언어를 사용한다.

  • such as "they"/"they"/"their", "it"/"its"

General Naming Rules

가독성을 최우선으로, 이름은 명확해야하고 줄임말(프로젝트 외부에서 알기 어려운 약어)은 피한다.

  • 단어 내부에서 글자를 삭제하여 축약하는 방식은 사용하지 않음 (cstmr_id ❌ , customer_id ✅)
  • 해당 약어가 위키피디아에 있다면 사용해도 괜찮음

짧은 코드 범위에서는 n, i 같은 이름이 괜찮지만, 클래스 범위에서는 더 구체적인 이름을 사용해야 한다.

  • 짧은 코드 = 5줄 함수
  • kMaxAllowedConnections ✅, kNum ❌

대문자 약어는 하나의 단어처럼 사용

  • StartRpc() ✅, StartRPC() ❌

File Names

모두 소문자여야 하며 밑줄(_) 또는 대시(-)를 포함할 수 있다.

  • 프로젝트에서 사용하는 규칙이 우선이며, 규칙이 없다면 밑줄을 선호한다.
my_useful_class.cc
my-useful-class.cc
myusefulclass.cc
myusefulclass_test.cc // _unittest and _regtest are deprecated.

 

파일 확장자 규칙을 따른다.

파일 유형 확장자 설명
소스 파일 .cc C++ 소스 코드 파일
헤더 파일 .h C++ 헤더 파일
포함 전용 파일 .inc 특정 위치에서 포함되는 파일

 

고유하면서 구체적인 파일명을 사용하고 시스템 헤더 파일과 이름 충돌을 피한다. (db.h, string.h)

  • 너무 일반적이지 않고 구체적인 의미를 담아야한다.
  • 좋은 예시 vs 나쁜 예시
logs.h               ❌ (너무 일반적)
http_server_logs.h   ✅ (더 구체적인 의미 전달)
foo_bar.h            ✅ (FooBar 클래스를 정의하는 파일)
foo_bar.cc           ✅ (FooBar 클래스의 구현 파일)

Type Names

항상 대문자로 시작하고, 단어 사이에 _ (언더스코어)를 사용하지 않는다.

새로운 단어의 시작은 대문자로 구분한다(PascalCase)

모든 타입(Class, Struct, Type Alias, Enum, Template parameters)에 동일한 규칙을 적용한다.

// classes and structs
class UrlTable { ...
class UrlTableTester { ...
struct UrlTableProperties { ...

// typedefs
typedef hash_map<UrlTableProperties *, std::string> PropertiesMap;

// using aliases
using PropertiesMap = hash_map<UrlTableProperties *, std::string>;

// enums
enum class UrlTableError { ...

Variable Names

변수 및 함수 매개변수는 snake_case (소문자 + 언더스코어) 형식을 사용한다.

std::string table_name;  // ✅ 올바른 변수명
int max_value;  // ✅ 올바른 변수명
void process_data(int input_value) { ... }  // ✅ 함수 매개변수도 snake_case 사용

std::string tableName;  // ❌ camelCase 사용 금지
std::string TableName;  // ❌ PascalCase 사용 금지
void ProcessData(int InputValue) { ... }  // ❌ 변수명에 대문자 사용 금지

Class의 데이터 멤버는 snake_case_ (언더스코어로 끝나도록) 형식을 사용한다.

class TableInfo {
 private:
  std::string table_name_;  // ✅ 클래스 데이터 멤버는 _로 끝남
  int record_count_;  // ✅ 클래스 내부 변수는 _로 끝남
  static Pool<TableInfo>* pool_;  // ✅ 정적 변수도 동일한 규칙 적용
};

class TableInfo {
 private:
  std::string tableName;  // ❌ camelCase 사용 금지
  int recordCount;  // ❌ camelCase 사용 금지
  static Pool<TableInfo>* Pool;  // ❌ PascalCase 사용 금지
};

Struct 의 데이터 멤버는 일반 변수처럼 snake_case를 사용한다.

struct UrlTableProperties {
  std::string name;  // ✅ 일반 변수처럼 snake_case 사용
  int num_entries;  // ✅ 정수형 변수도 snake_case 사용
  static Pool<UrlTableProperties>* pool;  // ✅ 정적 변수도 동일한 규칙 적용
};

struct UrlTableProperties {
  std::string name_;  // ❌ 구조체에서는 `_`를 붙이지 않음
  int numEntries;  // ❌ camelCase 사용 금지
  static Pool<UrlTableProperties>* Pool_;  // ❌ PascalCase 및 `_` 사용 금지
};

Constant Names

constexpr 또는 const 변수는 k로 시작해야하며, 다음 단어부터는 CamelCase를 적용한다. (kCamelCase)

단어 구분이 어려운 경우에만 _(언더스코어)를 사용한다.

const int kDaysInAWeek = 7;  // ✅ 'k'로 시작, CamelCase 사용
constexpr double kPi = 3.14159;  // ✅ 'k' 사용, 프로그램 실행 중 변하지 않음
const int kAndroid8_0_0 = 24;  // ✅ 언더스코어 사용 (숫자 구분이 어려운 경우)

template <typename T>
constexpr int kMaxBufferSize = 1024;  // ✅ 템플릿 변수지만, 모든 인스턴스에서 상수로 유지됨

지역 변수의 경우에는 적용할 필요가 없다.

void ComputeFoo(absl::string_view suffix) {
  const absl::string_view kPrefix = "prefix";  // ✅ 사용 가능 (지역 변수지만, 프로그램 실행 중 변하지 않음)
  const absl::string_view prefix = "prefix";  // ✅ 일반적인 네이밍도 허용됨
}

void ComputeFoo(absl::string_view suffix) {
  const std::string kCombined = absl::StrCat(kPrefix, suffix);  // ❌ 잘못된 예제

Function Names

일반적인 함수는 PascalCase 를 사용해야 한다.

void AddTableEntry();  // ✅ 올바른 예시
void DeleteUrl();  // ✅ 올바른 예시
void OpenFileOrDie();  // ✅ 올바른 예시

void add_table_entry();  // ❌ 함수는 PascalCase를 사용해야 함
void delete_url();  // ❌ 함수 이름을 소문자로 작성하면 안 됨

단, getter와 setter의 경우에는 변수처럼 snake_case 를 사용한다.

class Counter {
 public:
  int count() const { return count_; }  // ✅ 변수처럼 `snake_case` 스타일 사용 가능
  void set_count(int count) { count_ = count; }  // ✅ setter도 변수 스타일 허용

 private:
  int count_;
};

Namespace Names

소문자로 작성하며, 단어 사이에는 _(언더스코어)를 사용한다.

최상위 네임스페이스는 프로젝트 또는 팀 이름을 반영해야한다.

namespace websearch {  // ✅ 프로젝트 이름을 최상위 네임스페이스로 사용
namespace index_util {  // ✅ 단어 구분 시 언더스코어 사용
void BuildIndex();
}  // namespace index_util
}  // namespace websearch

namespace WebSearch {  // ❌ 대문자로 시작하면 안 됨
namespace IndexUtil {  // ❌ CamelCase 사용 금지
void BuildIndex();
}  // namespace IndexUtil
}  // namespace WebSearch

잘 알려진 최상위 네임스페이스(std, boost 등)와 충돌하지 않도록 해야한다.

네임스페이스 이름을 축약하면 안된다.

namespace websearch {  // ✅ 최상위 네임스페이스 = 프로젝트 이름
namespace index {  // ✅ 서브 네임스페이스 (구체적인 역할을 반영)
void BuildIndex();
}  // namespace index
}  // namespace websearch

namespace util {  // ❌ "util"은 너무 일반적이며 충돌 가능성이 높음
namespace index {
void BuildIndex();
}  // namespace index
}  // namespace util

Enumerator Names

모든 열거형(enum) 값은 kCamelCase 스타일을 사용해야 한다.

enum class UrlTableError {
  kOk = 0,             // ✅ 올바른 네이밍
  kOutOfMemory,        // ✅ CamelCase + k 접두사
  kMalformedInput,     // ✅ CamelCase + k 접두사
};

enum class AlternateUrlTableError {
  OK = 0,              // ❌ 매크로처럼 작성하면 안 됨
  OUT_OF_MEMORY = 1,   
  MALFORMED_INPUT = 2, 
};

Macro Names

매크로는 가급적 사용하지 않는다. 꼭 필요한 경우 SCREAMING_SNAKE_CASE(대문자+ _ )를 사용한다.

매크로 이름에는 프로젝트 접두사(prefix)를 포함한다.

#define MYPROJECT_ROUND(x) ((x) + 0.5)  // ✅ 프로젝트 접두사 포함
#define MYPROJECT_MAX_BUFFER_SIZE 1024  // ✅ 프로젝트 접두사 포함
#define DEBUG_MODE 1  // ✅ 글로벌 매크로는 대문자로 작성

#define MyProjectRound(x) ((x) + 0.5)  // ❌ PascalCase 사용 금지
#define my_project_max_buffer_size 1024  // ❌ 소문자 사용 금지
#define DebugMode 1  // ❌ CamelCase 사용 금지

일반적인 코드에서는 constexpr, inline, const 등을 대신 사용할 것을 권장한다.

  • 예시 1. 매크로 사용의 좋지 않은 방법과 그 대안
#define SQUARE(x) ((x) * (x))  // ❌ 위험: x가 식일 경우 예상치 못한 동작 가능

int result = SQUARE(3 + 1);  // 예상: (3+1) * (3+1) = 16
// 실제 동작: (3 + 1 * 3 + 1) = 7 (잘못된 결과)

// constexpr을 사용하는 방법
constexpr int Square(int x) {
    return x * x;
}

Exceptions to Naming Rules

C 표준 라이브러리와 유사한 함수는 기존 스타일을 유지한다.

int bigopen(const char* filename, int flags); // ✅ 기존 open() 함수 스타일 유지
int BigOpen(const char* filename, int flags); // ❌ C 스타일 함수는 PascalCase 사용하지 않음

C 스타일 타입 정의 (typedef or using)은 기존 스타일을 유지한다.

typedef unsigned int uint;  // ✅ 기존 C 스타일 유지
using uint = unsigned int;  // ✅ C++ 스타일 유지

typedef unsigned int UnsignedInt;  // ❌ `typedef`는 일반적으로 소문자 사용

STL 스타일을 따르는 경우, 기존 스타일을 유지한다.

template <typename Key, typename Value>
class sparse_hash_map {
    // ✅ STL 스타일 유지
};

template <typename Key, typename Value>
class SparseHashMap {  // ❌ STL 스타일을 따르지 않음
};

상수(constexpr 또는 #define)는 기존 C 스타일(SCREAMING_SNAKE_CASE)을 유지해야 한다.

#define LONGLONG_MAX 9223372036854775807LL  // ✅ 기존 INT_MAX 스타일 유지
constexpr long long LONGLONG_MAX = 9223372036854775807LL;  // ✅ 같은 스타일 유지

constexpr long long LongLongMax = 9223372036854775807LL;  // ❌ 기존 C 스타일과 다름
반응형

Google C++ Style Guide 정리하기 - Classes

반응형

Classes

Doing Work in Constructors

생성자에서 가상 메서드를 호출하지 않도록 하고, 오류 신호를 보낼 수 없는 경우 초기화가 실패할 수 있을 것을 방지해야 한다.

Implicit Conversions

암시적 변환을 정의하지말고, explicit 키워드를 사용한다.

class Foo {
  explicit Foo(int x, double y);
  ...
};

void Func(Foo f);
Func({42, 3.14});  // Error
Func(Foo(42, 3.14)); // OK

Copyable and Movable Types

클래스의 public API는 클래스가 복사가 가능한지, 이동만 가능한지, 복사하거나 이동할 수 없는지 여부를 분명하게 해야 한다.

  1. 복사 가능(Copyable)한 객체
  • 같은 타입의 다른 객체를 사용해서 생성 가능 (복사 생성자)
  • 같은 타입의 다른 객체를 사용해서 대입 가능 (복사 대입 생성자)
  • 원본 객체의 값은 변하지 않음 (즉, 원본과 동일한 객체를 가진 새로운 객체가 생성됨)
  • 예시 1. 복사 가능한 객체
int a = 10;
int b = a;  // ✅ 복사 가능

std::string s1 = "hello";
std::string s2 = s1;  // ✅ 복사 가능 (s2도 "hello"를 가짐)
  • 예시 2. 사용자 정의 복사 가능 클래스
class Copyable {
 public:
  Copyable(const Copyable& other) = default;  // 복사 생성자
  Copyable& operator=(const Copyable& other) = default;  // 복사 대입 연산자
};

 

 

2. 이동 가능(Movable)한 객체

  • 임시 객체(temporary object)로부터 데이터를 가져올 수 있는 객체
  • 이동이 가능한 경우, 복사보다 빠르게 데이터를 전송할 수 있음
  • 이동 이후 원본 객체의 상태는 “비워진(empty)” 상태 (이전 데이터를 다른 객체가 가져갔기 때문)
  • 예시 1. 이동 가능한 객체 (std::unique_ptr)
std::unique_ptr<int> p1 = std::make_unique<int>(10);
std::unique_ptr<int> p2 = std::move(p1);  // ✅ 이동 가능 (p1은 더 이상 10을 소유하지 않음)
  • 예시 2. 사용자 정의 이동 가능 클래스
 public:
  MoveOnly(MoveOnly&& other) = default;  // 이동 생성자
  MoveOnly& operator=(MoveOnly&& other) = default;  // 이동 대입 연산자

  MoveOnly(const MoveOnly&) = delete;  // 복사는 금지
  MoveOnly& operator=(const MoveOnly&) = delete;  // 복사는 금지
};

 

3. 객체 슬라이싱 문제

  • 기반 클래스(base class)를 복사할 때, 파생 클래스(derived class)의 정보가 손실되는 현상
  • 예시 1.
class Base {
 public:
  virtual void Print() { std::cout << "Base\n"; }
};

class Derived : public Base {
 public:
  void Print() override { std::cout << "Derived\n"; }
};

void Func(Base b) {  // ❌ 복사 생성자로 인해 slicing 발생
    b.Print();  // 항상 Base::Print() 호출됨
}

int main() {
    Derived d;
    Func(d);  // "Base"가 출력됨 (slicing 발생)
}
  • 예시 2. 해결 방법 (포인터 또는 참조 사용)
void Func(Base& b) {  // ✅ 참조를 사용하면 slicing 방지
    b.Print();
}

Inheritance

모든 상속(inheritance)은 public 으로 선언되어야 한다.

  • private 상속을 수행하려면 기본 클래스의 인스턴스를 구성원으로 대신 포함
  • 기본 클래스로 사용하는 것을 지원하지 않을 경우 final 키워드를 클래스 앞에 선언

상속의 사용을 "is-a"의 경우로 제한한다.

  • "Bar가 Foo의 한 종류" 라고 합리적으로 말할 수 있어야 함

인터페이스(interface) 상속은 virtual 클래스로 부터의 상속을 말한다.

  • 그 외는 구현(Implementation) 상속이라고 말함

하위 클래스에서 액세스해야 할 수 있는 멤버 함수로 protected의 사용을 제한한다.

다중 상속은 허용되지만 다중 구현 상속은 권장되지 않는다.

Access Control

상수가 아닌 경우 클래스의 데이터 멤버를 private으로 선언한다.

Declaration order

유사한 선언을 그룹화하고 public 부분을 먼저 배치한다.

클래스의 정의는 일반적으로 public: 섹션으로 시작하고 그 다음에 protected:, private: 가 따라와야 한다.

  • 비어 있는 섹션은 생략함

다음 순서를 선호한다.

  1. Types and type aliases (typedef, using, enum, nested structs and classes, and friend types)
  2. (Optionally, for structs only) non-static data members
  3. Static constants
  4. Factory functions
  5. Constructors and assignment operators
  6. Destructor
  7. All other functions (static and non-static member functions, and friend functions)
  8. All other data members (static and non-static)
반응형

Google C++ Style Guide 정리하기 - Scoping

반응형

Scoping

Namespaces

대부분의 코드가 합리적으로 짧은 이름을 사용할 수 있도록 하는 동시에 이름 충돌을 방지하는 방법을 제공한다.

  • 몇가지 예외를 제외하고는 네임스페이스에 코드를 배치한다
  • 가능한 프로젝트 이름과 경로를 기준으로 고유한 이름을 가져야 한다.
  • 아래 예제와 같이 주석을 달아 네임스페이스 종료를 알린다.
// In the .h file
namespace mynamespace {
 
// All declarations are within the namespace scope.
// Notice the lack of indentation.
class MyClass {
 public:
  ...
  void Foo();
};
 
}  // namespace mynamespace
// In the .cc file
namespace mynamespace {
 
// Definition of functions is within scope of the namespace.
void MyClass::Foo() {
  ...
}
 
}  // namespace mynamespace
  • inline namespace를 가급적 사용하지 않고, 꼭 사용해야한다면 아래의 예시처럼 default 인식에 주의한다.
    • 버전 관리같은 의도된 default 동작은 예외
    namespace CAR {
    namespace VER1 {
    class ElectricCar; // VER1 Class
    }  // namespace VER1
    
    inline namespace VER2 {
    class ElectricCar; // VER2 Class
    }  // namespace VER2
    
    class GasCar;
    
    }  // namepsace CAR
    
    // CAR::VER2::ElectricCar, VER2가 inline namespace이기 때문에 CAR namespace로 간주
    CAR::ElectricCar* car1;
    CAR::VER1::ElectricCar* car2;
    CAR::VER2::ElectricCar* car3;
    
  • using namespace 사용에 주의한다.
// Forbidden -- This pollutes the namespace.
using namespace foo;

// Shorten access to some commonly used names in .cc files.
namespace baz = ::foo::bar::baz;

 

Internal Linkage

함수, 변수 등이 해당 소스 파일(.cc)에서만 사용될 경우, 다른 파일에서 접근하지 못하도록 내부 연결을 부여한다.

  • Unnamed namespace 사용
namespace {
    int internalVar = 42;  // 다른 파일에서 접근 불가능
    void internalFunction() {
        // ...
    }
}  // namespace
  • static 키워드 사용
static int internalVar = 42;  // 다른 파일에서 접근 불가능
static void internalFunction() {
    // ...
}

내부 연결은 헤더 파일에서는 사용하 안된다.

  • 각각의 소스 파일에서 서로 다른 복사본이 생성되기 때문

Nonmember, Static Member, and Global Functions

비 멤버 함수와 정적 멤버 함수, 글로벌 함수의 적절한 사용이 필요하다.

  • 클래스에 속하지 않은 함수, Nonmember function 는 네임스페이스 안에 넣는다.
  • 글로벌 함수보다 네임스페이스를 활용한다.
  • 예시 1. 글로벌 네임스페이스의 오염
#include <iostream>

void PrintMessage() {  // 전역(global) 네임스페이스에 있음
    std::cout << "Hello, world!" << std::endl;
}
  • 예시 2. 올바른 예
#include <iostream>

namespace utils {
    void PrintMessage() {
        std::cout << "Hello, world!" << std::endl;
    }
}

int main() {
    utils::PrintMessage();
    return 0;
}

 

  • 정적 멤버 변수를 위한 클래스는 사용하지 않는다.
    • 예시 1. 클래스를 네임스페이스처럼 사용
class Utility {
public:
    static void PrintMessage() {
        std::cout << "Hello, world!" << std::endl;
    }
};

 

  • ODR(One Definition Rule) 문제 발생에 주의한다.
    • 같은 프로그램에서 동일한 이름의 함수가 여러 번 정의되면 컴파일 오류 발생
// file1.cpp
#include <iostream>
void PrintMessage() {  // 글로벌 함수
    std::cout << "Hello from file1!" << std::endl;
}

// file2.cpp
#include <iostream>
void PrintMessage() {  // 글로벌 함수 (중복 정의!)
    std::cout << "Hello from file2!" << std::endl;
}

// ❌ 링크 오류 발생! (ODR 위반)

Local Variables

가능한 가장 좁은 범위에 함수의 변수를 배치하고 선언에서 변수를 꼭 초기화한다.

  • C++ 에서는 함수의 어느 곳에서나 변수를 선언할 수 있다.
  • 처음 사용하는 곳에 가깝게 선언하는 것이 좋다.
    • 선언을 찾고 변수 유형과 초기화 대상을 쉽게 확인할 수 있음
    • 선언 및 할당 대신 초기화를 사용
      std::vector<int> v;
      v.push_back(1);  // Prefer initializing using brace initialization.
      v.push_back(2);
      
      std::vector<int> v = {1, 2};  // Good -- v starts initialized.
      
      std::vector<int> v;
      v.push_back(1);  // Prefer initializing using brace initialization.
      v.push_back(2);
      
      std::vector<int> v = {1, 2};  // Good -- v starts initialized.
  • If, while 및 for 문에 필요한 변수는 일반적으로 해당 statement 내에서 선언되어야 하며, 이러한 변수는 해당 범위로 제한된다.
while (const char* p = strchr(str, '/')) str = p + 1;
  • 변수가 객체인 경우, 해당 루프 외부에서 선언하는 것이 더 효율적이다.
// Inefficient implementation:
for (int i = 0; i < 1000000; ++i) {
  Foo f;  // My ctor and dtor get called 1000000 times each.
  f.DoSomething(i);
}

Foo f;  // My ctor and dtor get called once each.
for (int i = 0; i < 1000000; ++i) {
  f.DoSomething(i);
}

 

Static and Global Variable

정적 저장 수명(static storage duration)을 가진 객체는 프로그램이 시작될 때부터 종료될 때까지 존재하는 객체이다. 이러한 객체는 아래와 같은 경우에 생성된다.

  • 네임스페이스 수준의 전역 변수(global variable)
  • 클래스의 static 멤버 변수
  • 정적 함수 지역 변수(static function-local variable)
// 네임스페이스 스코프 (전역 변수)
const int globalValue = 42;  

// 클래스의 static 멤버 변수
class MyClass {
    static int classStaticVar;
};

// 함수 내부의 static 변수
void foo() {
    static int localStaticVar = 10;
}

이러한 변수들은 종료시 소멸되지만 여러 가지 문제를 유발할 수 있다.

  • 예시 1. 나쁜 예
// bad: non-trivial destructor
const std::string kFoo = "foo";

// Bad for the same reason, even though kBar is a reference (the
// rule also applies to lifetime-extended temporary objects).
const std::string& kBar = StrCat("a", "b", "c");

void bar() {
  // Bad: non-trivial destructor.
  static std::map<int, int> kData = {{1, 0}, {2, 0}, {3, 0}};
}
  • 예시 2. 좋은 예
const int kNum = 10;  // Allowed

struct X { int n; };
const X kX[] = {{1}, {2}, {3}};  // Allowed

void foo() {
  static const char* const kMessages[] = {"hello", "world"};  // Allowed
}

// Allowed: constexpr guarantees trivial destructor.
constexpr std::array<int, 3> kArray = {1, 2, 3};

thread_local Variables

thread_local 지정자를 사용하여 변수를 선언할 수 있다.

thread_local Foo foo = ...;

네임스페이스 범위, 함수 내부 또는 정적 클래스 멤버로 선언할 수 있지만 일반 클래스 멤버로는 선언할 수 없다.

  • 이러한 변수는 실제로 객체의 모임이므로 다른 스레드가 접근 할 때 실제로 다른 객체에 액세스 한다.
  • 변수 인스턴스는 프로그램 시작 시 한 번이 아니라 각 스레드에 대해 별도로 초기화되어야 한다는 점을 제외하고는 정적 변수와 매우 유사하게 초기화된다.
  • 즉, 함수 내에 선언된 thread_local 변수는 안전하지만 다른 thread_local 변수는 정적 변수(와 그 외)와 동일한 초기화 순서 문제의 영향을 받는다.
  • thread_local 변수 인스턴스들은 스레드가 종료되기 전에 소멸되지 않으므로 정적 변수의 소멸 순서 문제가 없다.
반응형

Google C++ Style Guide 정리하기 - Header Files

반응형

Header Files

일반적으로 모든 .cc 파일에는 연관된 .h 파일이 있어야 한다.

  • 단, 유닛 테스트 및 main() 함수만 포함하는 작은 .cc 파일과 같은 예외가 있음

헤더 파일을 올바르게 사용하면 코드의 가독성, 사이즈 및 성능 면에서 큰 차이를 가져올 수 있다.

Self-contained Headers

모든 헤더 파일은 독립적(self-contained)이어야 한다.

  • 여기서 독립적이란, abc.h, abc.cpp따로 파일을 만들어야 한다는 의미이다.
  • 단, template, inline function 에 대한 정의는 선언과 동일한 파일에 배치하는 걸 선호

The #define Guard

모든 헤더 파일에는 다중 포함을 방지하기 위해 #define 이 있어야 한다.

기호 이름의 형식은 PROJECT_PATH_FILE_H_ 여야 한다.

고유성을 보장하려면 프로젝트 소스 트리의 전체 경로를 기반으로 해야 한다.

예를 들어, foo 프로젝트의 foo/src/bar/baz.h 파일에는 아래와 같이 작성한다.

#ifndef FOO_BAR_BAZ_H_
#define FOO_BAR_BAZ_H_

...

#endif // FOO_BAR_BAZ_H_

Include What You Use

소스 또는 헤더 파일이 다른 곳에 정의된 기호를 참조하는 경우, 파일에는 해당 기호의 선언 또는 정의를 적절하게 제공하려는 헤더 파일이 직접 포함되어야 한다.

즉, 전이적 포함(transitive inclusion)에 의존하면 안된다.

//foo.h
#include "bar.h"
class Foo 
{
public:
    Bar bar;
};
//bar.h
class Bar
{
};
//foo.cc
#include "foo.h"
// #include "bar.h"
int main()
{
    Foo* foo = new Foo();
    Bar* bar = new Bar();
}
  • foo.h 가 bar.h를 포함하기에 .cc 파일에서 foo.h 만 포함하려는 시도

Forward Declaration

가능하면 전방 선언을 사용하지 않는다.

  • 대신 필요한 헤더 파일을 포함해야 함
  • C++ 20 부터는 모듈 시스템의 도입으로 문제점이 완화되었음

Inline Functions

10줄 이하의 함수는 인라인으로 정의한다.

  • loop 또는 switch 의 경우 효율적이지 않음
  • 재귀 함수는 인라인으로 지정하지 않음

Names and Order of Includes

다음의 순서로 포함한다 :
관련 헤더, C 시스템 헤더, C++ 표준 라이브러리 헤더, 기타 라이브러리 헤더, 프로젝트 헤더
프로젝트의 모든 헤더 파일은 UNIX 디렉터리 별칭 .(현재 디렉터리) 또는 ..(상위 디렉터리)를 사용하지 않고 프로젝트 소스 디렉터리의 하위 항목으로 나열되어야 한다.

  • 예시 1. google-awesome-project/src/base/logging.h 는 다음과 같이 포함되어야 한다.

    #include "base/logging.h"
  • 예시 2. google-awesome-project/src/foo/internal/fooserver.cc는 다음과 같을 수 있다:

    #include "foo/server/fooserver.h"
    
    #include <sys/types.h>
    #include <unistd.h>
    
    #include <string>
    #include <vector>
    
    #include "base/basictypes.h"
    #include "base/commandlineflags.h"
    #include "foo/server/bar.h"
  • 예외 1. 조건부 포함

    #include "foo/public/fooserver.h"
    
    #include "base/port.h"  // For LANG_CXX11.
    
    #ifdef LANG_CXX11
    #include <initializer_list>
    #endif  // LANG_CXX11
반응형

Google C++ Style Guide 정리하기 - 시작

반응형

https://google.github.io/styleguide/cppguide.html

 

Google C++ Style Guide

Google C++ Style Guide Background C++ is one of the main development languages used by many of Google's open-source projects. As every C++ programmer knows, the language has many powerful features, but this power brings with it complexity, which in turn ca

google.github.io

 

라떼썰 같은 꼰대 이야기일지 모르겠으나...
Code convention을 숙지하는 것은 협업의 시작이다.

 

보통 3개월인 수습 기간 동안 숙지할 것을 권장하며

수습이 끝난 후에는 프로젝트 코드에 가장 얕은 권한이 주어진다.

그리고 pull request, code review 를 거치며 코딩 스타일을 체득한다.

 

2022년 chatGPT 이후, 일단 구현해보자가 흐름이라면

앞으로의 이야기는 흐름을 거스른다고 느낄 수도 있겠다.

 

구글 스타일 가이드를 모두 번역할 계획보다는

정말로 필요한 부분만 번역해서 업로드할 계획이다.

 

1. Header Files

2. Scoping

3. Classes

4. Functions

5. Naming

6. Comments

7. Formatting

반응형

+ 최근 글