1.8 — Białe znaki i podstawowe formatowanie

Białe znaki to termin odnoszący się do znaków używanych do celów formatowania. W C++ odnosi się to przede wszystkim do spacji, tabulacji i znaków nowej linii. Białe znaki w C++ są zwykle używane do 3 celów: oddzielania pewnych elementów języka, wewnątrz tekstu i do formatowania kodu.

Niektóre elementy języka muszą być oddzielone białymi znakami

Składnia języka wymaga, aby niektóre elementy były oddzielone białymi znakami. Dzieje się tak najczęściej, gdy dwa słowa kluczowe lub identyfikatory muszą być umieszczone kolejno, aby kompilator mógł je rozróżnić.

Na przykład deklaracja zmiennej musi być oddzielona białymi znakami:

int x; // int and x must be whitespace separated

Jeśli zamiast tego wpiszemy intx , kompilator zinterpretuje to jako identyfikator, a następnie narzeka, że nie wie, jaki identyfikator intx jest.

Jako inny przykład, typ i nazwa zwracana funkcji muszą być białymi znakami rozdzielone:

int main(); // int and main must be whitespace separated

Kiedy jako separator wymagane są białe znaki, kompilator nie dba o to, ile białych znaków jest używanych, o ile takie istnieją.

Wszystkie poniższe definicje zmiennych są prawidłowe:

int x;
int                y;
            int 
z;

W niektórych przypadkach znaki nowej linii są używane jako separator. Komentarze jednoliniowe zakończone są znakiem nowej linii.

Przykładowo wykonanie czegoś takiego spowoduje kłopoty:

std::cout << "Hello world!"; // This is part of the comment and
this is not part of the comment

Dyrektywy preprocesora (np. #include <iostream>) muszą być umieszczone w oddzielnych wierszach:

#include <iostream>
#include <string>

Cytowany tekst oznacza dosłownie ilość białych znaków

Wewnątrz cudzysłowu brana jest ilość białych znaków dosłownie.

std::cout << "Hello world!";

różni się od:

std::cout << "Hello          world!";

Nowe linie nie są dozwolone w cudzysłowie:

std::cout << "Hello
     world!"; // Not allowed!

Cytowany tekst oddzielony wyłącznie białymi znakami (spacjami, tabulatorami lub znakami nowej linii) zostanie połączony:

std::cout << "Hello "
     "world!"; // prints "Hello world!"

Używanie białych znaków do formatowania kodu

W przeciwnym razie białe znaki są zazwyczaj ignorowane. Oznacza to, że możemy używać białych znaków wszędzie tam, gdzie chcemy sformatować nasz kod, aby ułatwić jego czytanie.

Na przykład poniższe jest dość trudne do odczytania:

#include <iostream>
int main(){std::cout<<"Hello world";return 0;}

Poniższe jest lepsze (ale wciąż dość gęste):

#include <iostream>
int main() {
std::cout << "Hello world";
return 0;
}

A jeszcze lepsze jest:

#include <iostream>

int main()
{
    std::cout << "Hello world";

    return 0;
}

W razie potrzeby instrukcje można podzielić na wiele wierszy:

#include <iostream>

int main()
{
    std::cout
        << "Hello world"; // works fine
    return 0;
}

Może to być przydatne przez szczególnie długi czas instrukcje.

Formatowanie podstawowe

W przeciwieństwie do niektórych innych języków, C++ nie narzuca programiście żadnych ograniczeń formatowania. Z tego powodu mówimy, że C++ jest językiem niezależnym od białych znaków.

To mieszane błogosławieństwo. Z jednej strony miło jest mieć swobodę robienia tego, co lubisz. Z drugiej strony, na przestrzeni lat opracowano wiele różnych metod formatowania programów w języku C++ i można znaleźć (czasami znaczące i rozpraszające) różnice zdań co do tego, które z nich są najlepsze. Naszą podstawową zasadą jest to, że najlepsze style to te, które tworzą najbardziej czytelny kod i zapewniają największą spójność.

Oto nasze zalecenia dotyczące podstawowego formatowania:

1. Do wcięć można używać tabulatorów lub spacji (większość IDE ma ustawienie, które pozwala przekonwertować naciśnięcie klawisza tabulatora na odpowiednią liczbę spacji). Programiści preferujący spacje zwykle to robią, ponieważ zapewnia to dokładne wyrównanie kodu zgodnie z zamierzeniami, niezależnie od używanego edytora i ustawień. Zwolennicy używania tabulatorów zastanawiają się, dlaczego nie użyć znaku przeznaczonego do tworzenia wcięć dla wcięć, zwłaszcza że można ustawić szerokość według własnych preferencji. Nie ma tu właściwej odpowiedzi – a debata na ten temat jest jak spór o to, czy lepsze jest ciasto czy ciasto. Ostatecznie sprowadza się to do osobistych preferencji.

Tak czy inaczej, zalecamy ustawienie wcięcia tabulatorów na 4 spacje. Niektóre IDE mają domyślnie 3 spacje wcięcia, co też jest w porządku.

2. Istnieją dwa konwencjonalne style nawiasów funkcyjnych.

Wielu programistów woli umieszczać otwierający nawias klamrowy w tym samym wierszu, co instrukcja:

int main() {
    // statements here
}

Uzasadnieniem tego jest to, że zmniejsza to ilość pionowych białych znaków (ponieważ nie poświęca się całej linii otwierającym nawiasowi klamrowemu), dzięki czemu można zmieścić więcej kodu na ekranie. Poprawia to zrozumienie kodu, ponieważ nie trzeba aż tak bardzo przewijać, aby zrozumieć, co robi kod.

Jednak w tej serii samouczków użyjemy popularnej alternatywy, w której nawias otwierający pojawia się w osobnej linii:

int main()
{
    // statements here
}

Poprawia to czytelność i jest mniej podatny na błędy, ponieważ pary nawiasów powinny zawsze mieć wcięcie na tym samym poziomie. Jeśli pojawi się błąd kompilatora z powodu niedopasowania nawiasów klamrowych, bardzo łatwo jest sprawdzić gdzie.

3. Każda instrukcja w nawiasach klamrowych powinna zaczynać się o jeden tabulator od nawiasu otwierającego funkcji, do której należy. Na przykład:

int main()
{
    std::cout << "Hello world!\n"; // tabbed in one tab (4 spaces)
    std::cout << "Nice to meet you.\n"; // tabbed in one tab (4 spaces)
}

4. Linie nie powinny być zbyt długie. Zazwyczaj 80 znaków było de facto standardem maksymalnej długości linii. Jeśli linia ma być dłuższa, należy ją podzielić (w rozsądnym miejscu) na wiele linii. Można to zrobić poprzez wcięcie każdej kolejnej linii dodatkowym tabulatorem lub, jeśli linie są podobne, wyrównując ją z linią powyżej (w zależności od tego, która z nich jest łatwiejsza do odczytania).

int main()
{
    std::cout << "This is a really, really, really, really, really, really, really, " 
        "really long line\n"; // one extra indentation for continuation line

    std::cout << "This is another really, really, really, really, really, really, really, "
                 "really long line\n"; // text aligned with the previous line for continuation line

    std::cout << "This one is short\n";
}

Dzięki temu linie będą łatwiejsze do odczytania. Na nowoczesnych monitorach szerokoekranowych umożliwia także umieszczenie obok siebie dwóch okien z podobnym kodem i łatwiejsze ich porównanie.

5. Jeśli długa linia jest dzielona operatorem (np. << lub +), operator powinien zostać umieszczony na początku następnej linii, a nie na końcu bieżącej linii

    std::cout << 3 + 4
        + 5 + 6
        * 7 * 8;

Dzięki temu staje się jaśniejsze, że kolejne linie są kontynuacją poprzednich linii i pozwala na wyrównanie operatorów po lewej stronie, co ułatwia czytanie.

6. Użyj białych znaków, aby ułatwić czytanie kodu, wyrównując wartości lub komentarze lub dodając odstępy między blokami kodu.

Trudniejsze do odczytania przeczytaj:

cost = 57;
pricePerItem = 24;
value = 5;
numberOfItems = 17;

Łatwiejsze do odczytania:

cost          = 57;
pricePerItem  = 24;
value         = 5;
numberOfItems = 17;

Trudniejsze do odczytania przeczytaj:

std::cout << "Hello world!\n"; // cout lives in the iostream library
std::cout << "It is very nice to meet you!\n"; // these comments make the code hard to read
std::cout << "Yeah!\n"; // especially when lines are different lengths

Łatwiejsze do odczytania:

std::cout << "Hello world!\n";                  // cout lives in the iostream library
std::cout << "It is very nice to meet you!\n";  // these comments are easier to read
std::cout << "Yeah!\n";                         // especially when all lined up

Trudniejsze do odczytania przeczytaj:

// cout lives in the iostream library
std::cout << "Hello world!\n";
// these comments make the code hard to read
std::cout << "It is very nice to meet you!\n";
// especially when all bunched together
std::cout << "Yeah!\n";

Łatwiejsze do odczytania:

// cout lives in the iostream library
std::cout << "Hello world!\n";

// these comments are easier to read
std::cout << "It is very nice to meet you!\n";

// when separated by whitespace
std::cout << "Yeah!\n";

Będziemy przestrzegać tych konwencji w całym tym samouczku i staną się one dla Ciebie drugą naturą. W miarę przedstawiania nowych tematów będziemy wprowadzać nowe zalecenia dotyczące stylu, które będą pasować do tych funkcji.

Ostatecznie C++ daje Ci możliwość wyboru stylu, w którym czujesz się najlepiej lub który uważasz za najlepszy. Zdecydowanie zalecamy jednak użycie tego samego stylu, którego używamy w naszych przykładach. Został przetestowany w walce przez tysiące programistów na miliardach linii kodu i został zoptymalizowany pod kątem sukcesu.

Jeden wyjątek: jeśli pracujesz w bazie kodu innej osoby, zastosuj jej styl. Lepiej stawiać na spójność niż na własne preferencje.

Automatyczne formatowanie

Większość nowoczesnych IDE pomoże Ci sformatować kod podczas jego wpisywania (np. podczas tworzenia funkcji IDE automatycznie wciśnie instrukcje wewnątrz treści funkcji).

Jednak gdy dodasz lub usuniesz kod, zmienisz domyślne formatowanie IDE lub wkleisz blok kodu o innym formatowaniu, formatowanie może zostać zepsute. Naprawianie formatowania części lub całości pliku może przyprawić o ból głowy. Na szczęście nowoczesne środowiska IDE zazwyczaj zawierają funkcję automatycznego formatowania, która ponownie sformatuje zaznaczenie (podświetlone myszką) lub cały plik.

W celu łatwiejszego dostępu zalecamy dodanie skrótu klawiaturowego w celu automatycznego formatowania aktywnego pliku.

Istnieją również zewnętrzne narzędzia, których można użyć do automatycznego formatowania kodu. clang-format jest popularnym formatem.

Przewodniki po stylu

A przewodnik po stylu to zwięzły, oparty na opiniach dokument zawierający (czasami dowolne) konwencje programistyczne, wytyczne dotyczące formatowania i najlepsze praktyki. Celem przewodnika po stylu jest zapewnienie, że wszyscy programiści biorący udział w projekcie programują w spójny sposób.

Niektóre powszechnie przywoływane przewodniki po stylu C++ obejmują:

• Podstawowe wytyczne C++, prowadzone przez Bjarne Stroustrup i Herb Sutter.
• Google.
• LLVM
• GCC/GNU

Ogólnie opowiadamy się za Podstawowymi wytycznymi C++, ponieważ są aktualne i mają szerokie zastosowanie.