Policies/Frameworks Coding Style: Difference between revisions

From KDE Community Wiki
m (Split top note in two, more focused this way)
m (Minor tweaks)
Line 198: Line 198:


== Clang-format automatic code formatting == <!--T:29-->
== Clang-format automatic code formatting == <!--T:29-->
By including the [https://api.kde.org/ecm/kde-module/KDEClangFormat.html KDEClangFormat] CMake module the [https://invent.kde.org/frameworks/extra-cmake-modules/-/blob/master/kde-modules/clang-format.cmake .clang-format file] is copied into the source folder. Using the provided `kde_clang_format` function one can create a target which formats all given files.
By including the [https://api.kde.org/ecm/kde-module/KDEClangFormat.html KDEClangFormat] CMake module the [https://invent.kde.org/frameworks/extra-cmake-modules/-/blob/master/kde-modules/clang-format.cmake .clang-format file] is copied into the source directory. Using the provided `kde_clang_format` function one can create a target which formats all given files.
Projects can enforce the formatting using a [https://api.kde.org/ecm/kde-module/KDEGitCommitHooks.html pre-commit hook] which uses the "git clang-format" tool to ensure the changes are properly formatted.
Projects can enforce the formatting using a Git [https://api.kde.org/ecm/kde-module/KDEGitCommitHooks.html pre-commit hook] which uses the "git clang-format" tool to ensure the changes are properly formatted.


Tips and tricks:
Tips and tricks:


<syntaxhighlight lang="cpp-qt">
<syntaxhighlight lang="cpp-qt">
// without trailing comma to enums and initializer lists
// Without a trailing comma to enums and initializer lists, clang-format will squash the members
// on one line (or more, if the length exceeds the 160 characters limit)
enum ViewType { FullView, CompactView };
enum ViewType { FullView, CompactView };
const QStringList values = {QStringLiteral("value1"), QStringLiteral("value2")};
const QStringList values = {QStringLiteral("value1"), QStringLiteral("value2")};


// with trailing comma to enums and initializer lists
// With a trailing comma to enums and initializer lists, clang-format will put each member on a separate line
enum ViewType {
enum ViewType {
     FullView,
     FullView,
Line 220: Line 221:


<syntaxhighlight lang="cpp-qt" id="clang-format preserve linebreaks">
<syntaxhighlight lang="cpp-qt" id="clang-format preserve linebreaks">
// the statement is longer than 160 characters, clang-format will break it into two lines
// If the statement is longer than 160 characters, clang-format will break it into two lines
const QStringList result =
const QStringList result =
     MyVeryVeryLongFunction(QStringLiteral("averyverylongparameterforthisfunction"), QStringLiteral("averyverylongparameterforthisfunction"));
     MyVeryVeryLongFunction(QStringLiteral("averyverylongparameterforthisfunction"), QStringLiteral("averyverylongparameterforthisfunction"));
// using a comment at the end to preserve the a manual linebreak
// You can use a comment '''//''' at the end to preserve the manual line-break
const QStringList result = MyVeryVeryLongFunction(QStringLiteral("averyverylongparameterforthisfunction"), //
const QStringList result = MyVeryVeryLongFunction(QStringLiteral("averyverylongparameterforthisfunction"), //
                                                   QStringLiteral("averyverylongparameterforthisfunction"));
                                                   QStringLiteral("averyverylongparameterforthisfunction"));
Line 231: Line 232:


<syntaxhighlight lang="cpp-qt">
<syntaxhighlight lang="cpp-qt">
// here the indentation feels a bit off because it is only indented one tab and not relatively to the variable declaration
// Here the indentation feels a bit off because it is only indented one tab and not relatively to the variable declaration
int resultFromComplexCalculation = someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename1
int resultFromComplexCalculation = someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename1
     + someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename2
     + someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename2
     + someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename3;
     + someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename3;
// adding parentheses around the entire statement will ensure sure it is indented relatively to the variable declaration
// Adding parentheses around the entire statement will ensure it is indented relatively to the variable declaration
int resultFromComplexCalculation = (someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename1
int resultFromComplexCalculation = (someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename1
                                     + someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename2
                                     + someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename2
Line 242: Line 243:
</syntaxhighlight>
</syntaxhighlight>


Also the formatting can be turned off for specific parts.
Also the formatting can be turned off for specific parts:
<syntaxhighlight lang="cpp-qt">
<syntaxhighlight lang="cpp-qt">
// clang-format off
// clang-format off
Line 249: Line 250:
</syntaxhighlight>
</syntaxhighlight>


But you should be careful with excluding parts from the formatting and only do this when it would break code or it would require too many manual interventions as suggested above
But you should be careful with excluding parts from the formatting and only do this when it would break code or it would require too many manual interventions as suggested above.


Document started by Urs Wolfer. Some parts of this document have been adopted from the Qt Coding Style document posted by Zack Rusin on kde-core-devel.
Document started by Urs Wolfer. Some parts of this document have been adopted from the Qt Coding Style document posted by Zack Rusin on kde-core-devel.


[[Category:Policies]] [[Category:C++]]
[[Category:Policies]] [[Category:C++]]

Revision as of 12:48, 29 March 2021

Note

This document describes the recommended coding style for KDE Frameworks. With Frameworks 5.80 Extra-CMake-Modules contains a finalized clang-format configuration file with this coding style.


Note

In short: KDE Frameworks coding style follows the Qt coding style, with one main difference: using curly braces even when the body of a conditional statement contains only one line.


Indentation

  • No tabs
  • 4 Spaces instead of one tab

Variable declaration

  • Each variable should be declared on a new line
  • Each new word in a variable name starts with a capital letter (so-called camelCase)
  • Avoid abbreviations
  • Use indicative/useful names. No short names, except:
    • Single character variable names can denote counters and temporary variables whose purpose is obvious
  • Variables and functions start with a lowercase letter
  • Member variable names should be prefixed with m_ to make it easier to distinguish them from function parameters and local variable names
    • The same applies to Private (d-pointer) class member variable names, (it may be a bit overkill when the Private class is merely used as a struct and all the code is in the public class, so you can use the m_ prefix everywhere to keep it consistent, or switch to prefixing m_ when adding the first method to a Private class)
  • Static (global) variable names should be prefixed with s_

Example:

// wrong
KProgressBar *prbar;
QString prtxt, errstr;

// correct
KProgressBar *downloadProgressBar;
QString progressText;
QString errorString;

Whitespace

  • Use blank lines to group statements
  • Use only one empty line
  • Use one space after each keyword
  • For pointers or references, use a single space before '*' or '&', but not after
  • No space after a cast

Example:

// wrong
QString* myString;
if(true){
}

// correct
QString *myString;
if (true) {
}

Enumerations

Ideally it should be one member per line.

Always add a trailing comma to the last member in an Enumeration. This helps produce better diffs (and has the good side-effect that code formatting tools, e.g. clang-format, will not put the whole enum on one line).

The same rule in the Braces section below applies, i.e. the left curly brace goes on the same line as the start of the statement.

Example:

// Wrong
enum ViewType
{
    FullView,
    CompactView
};

// Correct
enum ViewType {
    FullView,
    CompactView, // The last enum member should have a trailing comma
};

Braces

As a base rule, the left curly brace goes on the same line as the start of the statement.

Example:

// wrong
if (true)
{
}

enum ViewType
{
    FullView,
    CompactView
};

// correct
if (true) {
}

enum ViewType {
    FullView,
    CompactView,
};


Exception: Function implementations, class, struct and namespace declarations always have the opening brace on the start of a line.

Example:

void debug(int i)
{
    qDebug("foo: %i", i);
}

class Debug
{
};


Use curly braces even when the body of a conditional statement contains only one line.

Example:

// wrong
if (true)
    return true;

for (int i = 0; i < 10; ++i)
    qDebug("%i", i);


// correct
if (true) {
    return true;
}

for (int i = 0; i < 10; ++i) {
    qDebug("%i", i);
}

Switch statements

Case labels are on the same column as the switch

Example:

switch (myEnum) {
case Value1:
    doSomething();
    break;
case Value2:
    doSomethingElse();
    // fall through
default:
    defaultHandling();
    break;
}


Line breaks

Try to keep lines shorter than 160 characters. In case you don't like the clang-format results you can use intermediate variables or add manual linebreaks if needed, see the #clang-format preserve linebreaks snippet.

Qt Includes

  • If you add #includes for Qt classes, use only the class name.

Example:

// wrong
#include <QtCore/QString>


// correct
#include <QString>


Clang-format automatic code formatting

By including the KDEClangFormat CMake module the .clang-format file is copied into the source directory. Using the provided `kde_clang_format` function one can create a target which formats all given files. Projects can enforce the formatting using a Git pre-commit hook which uses the "git clang-format" tool to ensure the changes are properly formatted.

Tips and tricks:

// Without a trailing comma to enums and initializer lists, clang-format will squash the members
// on one line (or more, if the length exceeds the 160 characters limit)
enum ViewType { FullView, CompactView };
const QStringList values = {QStringLiteral("value1"), QStringLiteral("value2")};

// With a trailing comma to enums and initializer lists, clang-format will put each member on a separate line
enum ViewType {
    FullView,
    CompactView,
};
const QStringList values = {
    QStringLiteral("value1"),
    QStringLiteral("value2"),
};
// If the statement is longer than 160 characters, clang-format will break it into two lines
const QStringList result =
    MyVeryVeryLongFunction(QStringLiteral("averyverylongparameterforthisfunction"), QStringLiteral("averyverylongparameterforthisfunction"));
// You can use a comment '''//''' at the end to preserve the manual line-break
const QStringList result = MyVeryVeryLongFunction(QStringLiteral("averyverylongparameterforthisfunction"), //
                                                  QStringLiteral("averyverylongparameterforthisfunction"));


// Here the indentation feels a bit off because it is only indented one tab and not relatively to the variable declaration
int resultFromComplexCalculation = someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename1
    + someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename2
    + someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename3;
// Adding parentheses around the entire statement will ensure it is indented relatively to the variable declaration
int resultFromComplexCalculation = (someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename1
                                    + someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename2
                                    + someveryveryveryveryveryveryveryveryveryveryveryveryverylongvariablename3);

Also the formatting can be turned off for specific parts:

// clang-format off
Some fragile or from third parties imported code...
// clang-format on

But you should be careful with excluding parts from the formatting and only do this when it would break code or it would require too many manual interventions as suggested above.

Document started by Urs Wolfer. Some parts of this document have been adopted from the Qt Coding Style document posted by Zack Rusin on kde-core-devel.