Coding Style

This is how we write code in Dolphin. Because of multiple developers spread out over many many years, Dolphin is a mess of different coding standards. We stray from this ideal in many places in the code, but the mess is slowly but surely being cleaned up. Do try follow these guidelines for any new code.

The following astyle command will format very closely to our style:

astyle -A1TfpHUxdk1W1wYm0M2j filename.cpp

General Rules

 * Try to keep lines to 80 characters.
 * Prefer namespaces to classes with all members static.
 * Classes/OO is allowed, but keep it simple please. No crazy double visitor patterns etc.
 * Should you use iterators, always use pre-increment (++iter) over post-increment (iter++) where possible.
 * Use single tabs as indentation (tabs, not spaces).
 * Try to eliminate all warnings.
 * Define global variables at the top of the file/namespace they belong to.

Naming Rules

 * All class, struct and function names:
 * CamelCase
 * Compile-time constants:
 * ALL_CAPS
 * Template parameters:
 * T (capital letter)
 * All other variables:
 * lower_case_underscored
 * Variable prefixes:
 * globals
 * "g_"
 * class members
 * "m_"
 * statics
 * "s_"

Class Names

 * Use struct for POD types, class everywhere else.
 * Put class contents in public, protected, private order.
 * For each access level, put contents in constructors, destructor, operators, functions, variables order.
 * Omit unneeded sections.
 * Define static member variables first.
 * Define member functions in the order they were declared.
 * Follow the indentation/whitespace style shown in the example.

UsefulClass.h

 * 1) pragma once

class UsefulClass : public SomeParent, public AnotherParent { public: UsefulClass(int x, int y); int GetX const; int GetY const; protected: virtual void SomeProtectedFunction = 0;

static float s_some_variable; private: int m_x; int m_y; };

float UsefulClass::s_some_variable;

UsefulClass::UsefulClass(int x, int y)       : m_x(x) , m_y(y) {}

int UsefulClass::GetX const {       return m_x; }

int UsefulClass::GetY const {       return m_x; } // Every file should end in a newline

Indentation/Whitespace Style
Follow the indentation/whitespace style shown below.

namespace Example { // Namespace contents are not indented

// Declare globals at the top int g_foo = 0;

enum SomeEnum {       COLOR_RED, COLOR_GREEN, COLOR_BLUE };

struct Position {       int x, y; };

// Use "typename" rather than "class" here, just to be consistent template  void FooBar {       int some_array[] = {               5,                25,                7,                42        };

if (note == the_space_after_the_if) {               CallAfunction; }       else {               // Use a space after the // when commenting }

// Comment directly above code when possible if (some_condition) single_statement;

// Place a single space after the for loop semicolons for (int i = 0; i != 25; ++i) {               // This is how we write loops }       DoStuff(this, function, call, takes, up, multiple,                lines, like, this); if (this || condition_takes_up_multiple &&               lines && like && this || everything ||                alright || then) {       }

switch (var) {       // No indentation for case label case 1: {               int case_var = var + 3; DoSomething(case_var); break; }       case 3: DoSomething(var); return; // Always break, even after a return break; default: // Yes, even break for the last case break; }

std::vector you_can_declare, a_few, variables, like_this; }

}

DON'T DO
Do not do any of this.

// Try to avoid macros, use a constant variable instead
 * 1) define FOO_BAR 5

// Don't include wxWidgets (directly or indirectly) from Core
 * 1) include 

// No, put the curly-bracket on the next line void FooBar{ // Don't declare a bunch of variables at the top of a function // Declare variables when they are first needed int foo; float bar; std::string str; // No, put the curly-bracket on the next line if (condition) { }

// Don't use a semicolon for an empty body, use {} while (true); // Put a space between "while/if/switch" and the condition parenthesis while(true) {}       // Use "while (true)" if needed for {}       // Declare iterators within the for loop int i;       for (i = 0; i != 10; ++i) {}       // This makes it harder to read, put the statement on the next line if (condition) DoStuff; if (condition) CallFoo,     // This is legitimate code, but don't do it                CallBar;      // Try not to comment to the right of code // Save CamelCase for function and class names int LocalVariable = 5; // Avoid implicit conversion and even explicit cast to bool, this produces a warning in msvc // Use bool b = (some_int != 0); int some_int = 5; bool b = some_int;

// Avoid implicit conversions to smaller types and between float/int, it causes warnings u32 u = some_u64; float f = u;       /* Don't use multiline comments */ }