코딩 스타일 지침서

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

ReturnType LongClassName::ReallyLongFunctionName(Type par_name1, Type par_name2,
                                                 Type par_name3)
{
    DoSomething(); // 1 tab indent
    ...
}

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

if (...)
{
    bool retval = DoSomethingThatRequiresALongFunctionName(
        very_long_argument1, // 1 tab indent
        argument2,
        argument3,
        argument4);
}

if (condition) // no spaces inside parentheses
{
    ... // 1 tab indent.
}
else if (...)
{
    ...
}
else
{
    ...
}

if (condition)
{
    DoSomething(); // 1 tab indent.
}

if (condition)
{
    DoSomething(); // 1 tab indent.
}
if (x == kFoo)
{
    return new Foo();
}

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

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

while (condition)
{
}

for (int i = 0; i < kSomeNumber; ++i)
{
}

while (condition)
{
    continue;
}

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

// These are fine, space preceding.
char *c;
const 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);

int x = 3;
int x(3);
string name("Some Name");
string name = "Some Name";

// Good - directives at beginning of line
    if (lopsided_score)
    {
#if DISASTER_PENDING // Correct -- Starts at beginning of line
        DropEverything();
# if NOTIFY // OK but not required -- Spaces after #
        NotifyClient();
# endif
#endif
        BackToNormal();
    }

// When it all fits on one line:
MyClass::MyClass(int var) : some_var_(var), some_other_var_(var + 1)
{
}

// When it requires multiple lines, indent 2 tab, putting the colon on
// the first initializer line:
MyClass::MyClass(int var)
        : some_var_(var), // 2 tab indent
          some_other_var_(var + 1) // 2 tab indent + 2 space
{
    ...
    DoSomething();
    ...
}

namespace foo {
namespace bar {

void foo() // Correct. No extra indentation within namespace
{
    ...
}

} // namespace bar
} // namespace foo

int i = 0; // Semicolons usually have no space before them.
int x[] = {0};
// Spaces around the colon in inheritance and initializer lists.
class Foo : public Bar
{
public:
    // For inline function implementations, put spaces between the braces
    // and the implementation itself.
    Foo(int b) : Bar(), baz_(b) {} // No spaces inside empty braces.
    void Reset() { baz_ = 0; } // Spaces separating braces from implementation.
}
}

while (test) // There is usually no space inside parentheses.
switch (i)
for (int i = 0; i < 5; ++i)
for (; i < 5; ++i) // For loops always have a space after the
                   // semicolon.
switch (i)
case 1: // No space before colon in a switch case.
        ...
case 2: break; // Use a space after a colon if there's code after it.

x = 0; // Assignment operators always have spaces around
       // them.
x = -5; // No spaces separating unary operators and their
++x; // arguments.
if (x && !y)
    ...
v = w * x + y / z; // Binary operators usually have spaces around them,
v = w*x + y/z; // but it's okay to remove spaces around factors.
v = w * (x + z); // Parentheses should have no spaces inside them.

vector<string> x; // No spaces inside the angle
y = static_cast<char*>(x); // brackets (< and >), before
                           // <, or between >( in a cast.

//=============================================================================
//
// Copyright (c) 2010-2012, JS Solution All Rights Reserved.
//
// No part of this program may be copied, reproduced, stored in a
// retrieval system, or transmitted in any form or by any means
// - electronic, mechanical, photocopying, recording, or otherwise -
// without written permission of the licensee, JS Solution
//
//==============================================================================
///
/// @file hdsr.cpp
/// @brief hdsr process
///
/// 실행중인 서버가 Master인 경우 HDSR버퍼에 저장된 포인트 값을 읽어서 이력데이터파일로
/// 저장하고 Hdsr Sync를 통해 Slave에게 포인트 값을 보낸다. 실행중인 서버가 Slave인 경우
/// Hdsr Sync를 통해 Master로부터 포인트 값을 전달받아 이력데이터파일로 저장한다.
///
/// @author ws.woo
/// @date 2011-10-05
///

///
/// @brief 여기에 클래스에 대한 설명을 적는다.
///
/// 클래스에 대한 자세한 설명
///
/// 사용 예:
/// @verbatim
/// GargantuanTableIterator* iter = table->NewIterator();
/// for (iter->Seek("foo"); !iter->done(); iter->Next())
/// {
///     process(iter->key(), iter->value());
/// }
/// delete iter;
/// @endverbatim
///
class GargantuanTableIterator
{
    ...
};

class MyClass
{
public:
///
/// @brief 함수에 대한 간단한 설명
/// 함수에 대한 간단한 설명 좀 더
///
/// 함수에 대한 자세한 설명
/// 기타 자세한 설명
///
/// @param [in] param1
/// param1에 대한 설명
/// @param [in,out] param2
/// param2에 대한 설명
/// @param [out] param3
/// param3에 대한 설명
///
/// @return 출력값에 대한 설명
/// @retval 1 성공
/// @retval 0 실패
int Foo(int value);
}

//
// @brief
// A brief description of the function.
// More brief description.
//
// Details follow here.
// Maybe an example or something.
//
// @param value
// Parameter description for parameter named 'value'
//
// @return description
int MyClass::Foo(int value)
{
    return value + 2;
}

private:
    /// Keeps track of the total number of entries in the table.
    /// Used to ensure we do not go over the limit. -1 means
    /// that we don't yet know how many entries the table has.
    int num_total_entries_;

    /// The total number of tests cases that we run through in this regression test.
    const int kNumTestCases = 6;

    const int kNumTestCases = 6; ///< description for kNumTestCases

// Divide result by two, taking into account that x
// contains the carry from the add.
for (int i = 0; i < result->size(); i++)
{
    x = (x << 8) + (*result)[i];
    (*result)[i] = x >> 1;
    x &= 1;
}

bool success = CalculateSomething(interesting_value,
                                  10, // Default base value.
                                  false, // Not the first time we're calling this.
                                  NULL); // No callback.

const int kDefaultBaseValue = 10;
const bool kFirstTimeCalling = false;
Callback *null_callback = NULL;
bool success = CalculateSomething(interesting_value,
                                  kDefaultBaseValue,
                                  kFirstTimeCalling,
                                  null_callback);

// TODO(kl@gmail.com): Use a "*" here for concatenation operator.
// TODO(Zeke) change this to use relations.

int num_errors; // Good.
int num_completed_connections; // Good.

// Good
// These show proper names with no abbreviations.
int num_dns_connections; // Most people know what "DNS" stands for.
int price_count_reader; // OK, price count. Makes sense.

OpenFile();
set_num_errors()

my_useful_class.cpp
myusefulclass.cpp
myusefulclass_test.cpp

FooBar.h
FooBar.cpp

UrlTable.h
UrlTable.cpp
UrlTableFoo.inc

// classes and structs
class UrlTable
{

class UrlTableTester
{

struct UrlTableProperties
{

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

// enums
enum UrlTableErrors
{

string table_name; // OK - uses underscore.
string tablename; // OK - all lowercase.

class Test
{
private:
    string table_name_; // OK - underscore at end.
    string tablename_; // OK.
}

struct UrlTableProperties
{
    string name;
    int num_entries;
}

const int kDaysInAWeek = 7;

AddTableEntry()
DeleteUrl()
OpenFileOrDie()

class MyClass
{
public:
    ...
    int num_entries() const { return num_entries_; }
    void set_num_entries(int num_entries) { num_entries_ = num_entries; }

private:
    int num_entries_;
};

enum UrlTableErrors
{
    kOK = 0,
    kErrorOutOfMemory,
    kErrorMalformedInput,
};

bigopen() // function name, follows form of open()
sparse_hash_map // follows STL naming conventions
LONGLONG_MAX // a constant, as in INT_MAX

// Copyright 문

#ifndef FILE_IO_H_
#define FILE_IO_H_

// src/common_code/file_system/file_io.h 파일인 경우

#endif // FILE_IO_H_

// 또는

#ifndef COMMON_CODE_FILE_SYSTEM_FILE_IO_H_
#define COMMON_CODE_FILE_SYSTEM_FILE_IO_H_

// src/common_code/file_system/file_io.h 파일인 경우

#endif // COMMON_CODE_FILE_SYSTEM_FILE_IO_H_

#include "foo/public/fooserver.h" // Preferred location.

#include <sys/types.h>
#include <unistd.h>

#include <hash_map>
#include <vector>

#include <boost/interprocess/sync/named_mutex.hpp>
#include <boost/shared_ptr.hpp>

#include "base/basictypes.h"
#include "base/commandlineflags.h"
#include "foo/public/bar.h"

class MyClass : public OtherClass
{
public: // Note the no indent!
    MyClass(); // Regular 1 tab indent.
    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_;
    DISALLOW_COPY_AND_ASSIGN(MyClass);
};

class SampleClass
{
public:
    static const int kMaxRetry = 3;
    inline int foo() { return foo_; } // accessor 함수
    inline void set_foo(int foo) { foo_ = foo; } // mutator 함수

private:
    int foo_; // Sample
};

// This is in a .cpp file.
namespace {

// The content of a namespace is not indented
enum { kUnused, kEOF, kError }; // Commonly used tokens.
bool AtEof() { return pos_ == kEOF; } // Uses our namespace's EOF.

} // namespace

#include "a.h"

DEFINE_bool(someflag, false, "dummy flag");

class C; // Forward declaration of class C in the global namespace.
namespace a { class A; } // Forward declaration of a::A.

namespace b {

// Definition of functions is within scope of the namespace.
void MyClass::Foo()
{
    ...
}

} // namespace b

// OK in .cc files.
// Must be in a function, method or class in .h files.
using ::foo::bar;

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

// Shorten access to some commonly used names (in a .h file).
namespace librarian {
// The following alias is available to all files including
// this header (in namespace librarian):
// alias names should therefore be chosen consistently
// within a project.
namespace pd_s = ::pipeline_diagnostics::sidetable;

inline void my_inline_function()
{
    // namespace alias local to a function (or method).
    namespace fbz = ::foo::bar::baz;
    ...
}
} // namespace librarian

int j = g(); // Good