# Varför C++ skapades

15 januari 2025 | https://www.ribomation.se/blog/2025/varfor-c++-skapades/

Bjarne Stroustrup skapade programspråket C++ 1979. Men varför då? Samt, vilka programspråk fanns innan dess och bidrog till utformningen av C++. Dessa frågor, och några till, ska jag besvara i denna artikel.

Hela händelsekedjan jag kommer att beskriva utspelar sig på Bell Labs, som var vid denna tiden (1960-talet och 1970-talet) ett forskningscentra för telefonbolaget AT&T.

Det började med att _Ken Thompson_ i slutet på 1960-talet utvecklade språket _B_, som var en kraftigt nedbantad version av språket _BCPL_ (**B**asic **C**ombined **P**rogramming **L**anguage). Målsättningen med B var att fungera som implementationsspråk för operativsystemet Multics (**Multi**plexed **C**omputing **S**ystem).

Utmärkande för språket B, var att det bara fanns en datatyp, nämligen _machine word_. Beroende på kontext så kunde det tolkas som ett heltal eller en adress i minnet. Så här kunde ett litet program se ut:

```c
compute(a, x, b) {
    auto result;
    result = a * x + b;
    return result;
}

main() {
    extrn printf, compute;
    auto answer;
    answer = compute(5, 6, 12);
    printf("the answer to everything is %d*n", answer);
}
```

En lokal variabel deklarerades med `auto`, vilket stod för _automatic storage_. Termen hänför sig till att minnes blocket för en lokal variabel allokerades automatiskt i samband med funktionsanropet och deallokerades i samband med funktionsretur. Under 1960-talet var stackbaserade programspråk en stor nyhet. Vare sig COBOL eller tidiga versioner av FORTRAN hade stackbaserad exekvering.

I början på 1970-talet började utvecklingen av operativsystemet Unics (**Uni**plexed **C**omputing **S**ystem). Något senare ändrades stavningen till UNIX. _Dennis Ritchie_ var inte nöjd med B, eftersom det saknades stöd för datatyper. Han designade och byggde vidare på språket och kallade det först _B with types_, sedemera kallat _C_. Språket C har sedan början av 1970-talet varit omåttligt populärt för maskinnära programmering. Så här kunde ett program se ut på den tiden:

```c
#include <stdio.h>

double compute(a, x, b) 
  int a, b; 
  float x;
{
    double result;
    result = a * x + b;
    return result;
}

void main(argc, argv) 
  int argc;
  char* argv[];
{
    double compute();
    int answer;
    answer = (int)compute(5, 6, 12);
    printf("the answer to everything is %d\n", answer);
}
```

Här ovan ser vi att lokala variabler har explicit typning, samt att funktionsparametrar och returtyp ävenså. Du kanske undrar över varför en funktion inte skrevs som vi gör nuförtiden: `double compute(int a, float x, int b)`. Skälet är Bjarnes förtjänst med C++ och man uppdaterade syntaxen för C i slutet på 1980-talet i enlighet med syntaxen för C++.

I mitten på 1970-talet var Bjarne Stroustrup klar med sina studier på Århus universitet i Danmark. Han hade då programmerat mycket i språket SIMULA (**Simul**ation **La**nguage) och skrivit stora simuleringsprogram. Simula skapades under 1960-talet av _Ole-Johan Dahl_ och _Kristen Nygaard_ på _Norsk Regnesentral_ och lade grunden för det vi idag förknippar med objekt-orienterad programmering, såsom klasser, arv och funktionsanrop med dynamisk binding. Så här kunde ett SIMULA program se ut:

```pascal
BEGIN
    INTEGER answer;
    REAL x;

    REAL PROCEDURE compute(a, x, b);
        INTEGER a, b;
        REAL x;
    BEGIN
        compute := a * x + b;
    END;

    x := 6.0;
    answer := ENTIER( compute(5, x, 12) );

    OutText("the answer to everything is ");
    OutInt(answer, 0);
    OutImage;
END;
```

Bjarnes uppgift var att skriva simuleringssystem för Bell Labs. Kruxet för Bjarne var att allt som behövdes för objekt-orienterad programmering saknades helt i C. Därför skrev han en pre-processor med namnet `cfront`, som konverterade programkoden till vanlig C. I början kallade han språket bara för _C with Classes_. Det var först efter några år och det börjat bli populärt, som kollegan _Rick Mascitti_ hittade på namnet _C++_.

Bjarne utökade `struct` syntaxen med medlemsfunktioner, vilket senare blev till `class`. Han införde referenser som en typsäkrare form av pekare, arv och dynamisk bindning, operator-överlagring och mycket mer. Så här kunde ett C++ program se ut på den tiden:

```cpp
#include <iostream>

double compute(int a, float x, int b) {
    return a * x + b;
}

int main(int argc, char* argv[]) {
    int answer = int( compute(5, 6, 12) );
    cout << "the answer to everything is " << answer << "\n";
}
```

Under det senaste decenniet, med start 2011, har C++ evolverat i rasande takt och blivit ett mycket modern och faktiskt hippt programspråk. En ny standard kommer var tredje år och den senaste heter C++23. Så här kan ett modernt C++ program se ut, vilket använder modules:

### file: compute.ixx

```cpp
export module compute;

export double compute(int a, float x, int b) {
    return a * x + b;
}
```

### file: main.cxx

```cpp
import compute;
import std.io;

int main() {
    auto answer = static_cast<int>( compute(5, 6, 12) );
    std::cout << "the answer to everything is " << answer << "\n";
}
```

Modules, som kom i C++20, är ett lovande tillskott och kommer att reducera total byggtid radikalt. Realiseringen av modules i kompilatorer och byggsystem, har väl fortfarande en bit kvar, men det finns hyfsade implementationer i de senare versionerna av GCC och CMake.