C++ Academy · Lektion

std::string jämfört med C-stilens char-arrayer

Jämför moderna std::string med äldre nullterminerade char-arrayer och avgör när respektive variant bör användas.

Lektion 1 av 413 steg

std::string jämfört med C-stilens char-arrayer är en gratis lektion i C++ Academy på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för C++ Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C++ Academy innehåller totalt 4 lektioner.

Två sätt att lagra text

C++ ärver C-strängar — nollterminerade char-arrayer — och lägger till std::string från standardbiblioteket. Använd nästan alltid std::string.

C-strängar

En C-sträng är en sekvens av char som avslutas med en nollbyte '\0'. Funktioner som strlen går igenom arrayen tills de hittar nolltecknet.

const char* greeting = "Hello";
// Memory: H, e, l, l, o, \0  (6 bytes)

#include <cstring>
std::cout << std::strlen(greeting);  // 5

std::string

std::string hanterar sitt eget minne och växer efter behov. Skapa den på samma sätt som vilken annan typ som helst.

#include <string>
std::string name = "Ada";
name += " Lovelace";
std::cout << name;  // Ada Lovelace

Storlek och längd

std::string::size() och length() är synonymer och returnerar antalet tecken (utan nollterminatorn).

std::string s = "hello";
std::cout << s.size();   // 5
std::cout << s.length(); // 5

Åtkomst via index

Läs eller skriv tecken med [] eller at(). Till skillnad från [] kastar at() ett undantag om indexet ligger utanför intervallet.

std::string s = "cat";
char first = s[0];        // 'c'
char last  = s.at(2);     // 't'
// s.at(10) throws std::out_of_range

Tomma strängar

Använd empty() i stället för size() == 0. Det är tydligare och lika snabbt.

När du bör använda const char*

Använd en C-sträng när:

Du integrerar med C-bibliotek eller operativsystemets API:er
Du arbetar med strängliteraler som aldrig ändras
Du utvecklar för inbyggda system där standardbiblioteket inte är tillgängligt

Konvertera mellan dem

Hämta en C-sträng från en std::string med .c_str(). Skapa en std::string direkt från en const char*.

std::string s = "Hello";
const char* c = s.c_str();

const char* literal = "world";
std::string s2(literal);

Strängliteraler är const char[]

En strängliteral som "hi" har typen const char[3] (inklusive nollterminatorn). Den lagras i skrivskyddat minne.

Råa strängliteraler

Använd prefixet R"(...)" för att hoppa över behandling av escape-sekvenser. Det är användbart för reguljära uttryck och filsökvägar.

std::string regex = R"(\d+\.\d{2})";
std::string path  = R"(C:\Users\Ada)";

Iterera över en std::string

Strängar är behållare. Gå igenom dem med en range-baserad for-loop, index eller iteratorer.

std::string s = "abc";
for (char c : s) std::cout << c << " ";  // a b c

Snabbkontroll

Vilken metod i std::string kastar ett undantag när indexet ligger utanför intervallet?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Föredra std::string för text som hanteras automatiskt. Använd const char* för literaler och interoperabilitet med C-API:er. Konvertera mellan dem med .c_str() och direkt konstruktion.

Gratis att börja

Lär dig C++ med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”std::string jämfört med C-stilens char-arrayer” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen C++ Academy, inklusive ”std::string jämfört med C-stilens char-arrayer”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i C++ Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”std::string jämfört med C-stilens char-arrayer”?

Jämför moderna std::string med äldre nullterminerade char-arrayer och avgör när respektive variant bör användas. Ni övar på C++ Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C++ Academy?

Du behöver inga förkunskaper. Utbildningen i C++ Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”std::string jämfört med C-stilens char-arrayer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C++ Academy-lektionen?

Ja. Varje C++ Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

std::string jämfört med C-stilens char-arrayer
Strängoperationer: concat, substr, find, replace
Stringstream: stringstream för parsning
Strängkonverteringar: to_string och stoi

← Tillbaka till C++ Academy