[itk] Számítástechnika kezdőknek

C++ programozás kezdőknek - gyakori műveletek

[2021. január 12.] [ christo161 ]

Az előző tananyagrészben csak a legalapvetőbb műveletekről volt szó (kezdőértékadás, értékadás, parancssorból történő bekérés, parancssorba való kiíratás). Ebben a tananyagrészben néhány, az eddigi ismeretekhez kapcsolódó gyakori műveletet nézünk át.

Ez a tananyagrész jelenleg átdolgozás alatt áll.

előző tananyagrész: változók, konstansok, literálok
következő tananyagrész: alaptípusok jellemzői

Tartalom

Inkrementálás, dekrementálás

Egy (általában int típusú) változó értékének a növelése (inkrementálás) vagy csökkentése (dekrementálás) eggyel. Noha elsőre azt gondolhatnánk, hogy ez egy nagyon egyszerű művelet, a C++ nyelvben viszonylag sok tudnivaló és tévhit kapcsolódik hozzá. Az inkrementálást, dekrementálást leggyakrabban for ciklusban használjuk több adatot tartalmazó adatszerkezetek (pl. tömb vagy std::vector) feldolgozásához, de a ciklusok, tömbök ismerete nem szükséges az itt leírtak megértéséhez.

Ha önálló utasításként (például i++; vagy ++i;), nem pedig egy összetett kifejezés részeként (például variable = i++ vagy array_of_sth[i++] = 0 vagy n == i++) használjuk a ++ operátort (vagy dekrementálás esetén a -- operátort), akkor az eredmény szempontjából mindegy, hogy a megnövelni kívánt változó neve elé vagy mögé rakjuk, ekkor mindkettő ugyanazt jelenti, mint i = i + 1; (vagy j esetén j = j + 1;). Ebben a példában mindkét esetben a már eggyel megnövelt érték lesz kiírva.

int i = 0;
++i;
std::cout << i << '\n';
int j = 0;
j++;
std::cout << j << '\n';

Ha viszont összetett kifejezésben használjuk, akkor...

1. ha a ++ operátor a változó neve előtt szerepel (ezt nevezzük prefix inkrementálásnak), akkor a változó értéke először megnövelődik, és az összetett kifejezésben a már eggyel megnövelt érték kerül felhasználásra.
Ebben a példában mindkét utasításban az eggyel megnövelt érték lesz kiírva.

int i = 0;
std::cout << ++i << '\n';
std::cout << i << '\n';

Ezzel teljesen egyenértékű, ha ezt írjuk:

int i = 0;
std::cout << i = i + 1 << '\n';
std::cout << i << '\n';

Hasonló példa:

int i = 0;
int a = ++i;
std::cout << "i erteke: " << i << ", a erteke: " << a << '\n';

Ekkor az a változó értéke az i változó egyel megnövelt értéke lesz, vagyis ezen példa esetén 1.

2. ha a ++ operátor a változó neve után szerepel (ezt nevezzük postfix inkrementálásnak), akkor a változó eggyel még meg nem növelt értéke lesz felhasználva az összetett kifejezésben, és a változó értéke a ++ operátort tartalmazó utasítás végrehajtása után lesz csak eggyel megnövelve.
Ebben a példában először a még meg nem növelt érték lesz kiírva, aztán pedig a megnövelt.

int j = 0;
std::cout << j++ << '\n';
std::cout << j << '\n';

Hasonló példa:

int i = 0;
int a = i++;
std::cout << "i erteke: " << i << ", a erteke: " << a << '\n';

Ekkor az a nevű változó értéke az i változó még meg nem növelt értéke lesz (ezen példa esetén 0), az i változó értéke viszont az int a = i++; utasítást követően megnövelődik (ezen példa esetén 1 lesz).

Egy összetett kifejezésben viszont már nem ugyanazt jelenti a j++ és a j = j + 1, hiszen az utóbbi a már megnövelt értéket fogja jelenteni az összetett kifejezésben.
Vagyis ez a két példa nem ugyanazt eredményezi:

int j = 0;
std::cout << j++ << '\n';
int j = 0;
std::cout << (j = j + 1) << '\n';

A felső példa esetén 0 íródik ki, az alsó esetén pedig 1. (Azt követően pedig mindkét esetben 1 lesz a j nevű változó értéke).

Esetleg talán a vessző (angolul comma) operátorral lehetne olyan utasítást csinálni, amiben nincs ++ operátor, de az eggyel meg nem növelt értéket értékeli ki az összetett kifejezés, viszont a változó értéke attól még eggyel megnövelődik. Ezen két példa végeredményben egyenértékű:

int j = 0;
std::cout << j++ << '\n';
int j = 0;
std::cout << (j = j + 1, j - 1) << '\n';

Mindkét esetben 0 íródik ki, és azt követően a j nevű változó értéke 1 lesz, viszont a köztes lépések különbözőek mert a második példa esetén először lesz elvégezve a növelés, majd az eggyel lecsökkentett érték kerül átadásra az insertion operátornak, amely a kiírást végzi el.

A vessző operátor működését valahogy úgy képzelhetjük el, mintha a helyére csak a vessző jobb oldalán lévő kifejezést írtuk volna, de a bal oldalán lévő kifejezés a háttérben mégis kiértékelődik/végrehajtódik még a vessző jobb oldalán lévő kifejezés kiértékelése előtt.

Fontos kihangsúlyozni, hogy az inkrementálás jelentése (monduk egy i nevű változó esetén) nem i + 1, hanem i = i +1. Előfordulhat, hogy egy változó értékének az eggyel megnövelt értékét csak fel szeretnénk használni (pl. kiíratni), de nem szeretnénk megnövelni a változó értékét (ekkor az i + 1 kifejezést használjuk az i = i + 1 vagy ++i vagy i++ kifejezések helyett). Figyeljünk a kettő közti különbségre, mert ha összekeverjük, hibát okozhatunk.

A ++ operátor nem használható immutable adatokhoz

A ++ vagy -- operátort csak olyan dolgok növelésére, csökkentésére használhatjuk, amiknek az értéke megváltoztatható, például a változók, vagy későbbi tananyagrészben tárgyalt objektumok adattagjai. A literálok, konstansok értékét például nem változtathatjuk meg ++ vagy -- operátorokkal, különben fordítási hibát kapunk.

//error
std::cout << ++2 << '\n';
std::cout << 3++ << '\n';
//error
const int a = 128; ++a;

Önálló utasításként i++ helyett ++i-t használjunk

Teljesítménybeli különbség akkor is van, ha az inkrementálást különálló utasításként használjuk, nem egy összetett kifejezés részeként. Ha postfix inkrementálást használunk (i++), akkor a még meg nem növelt értéket ideiglenesen tárolni kell az utasítás kiértékeléséig.
Tehát ha nem egy összetett kifejezés részeként használjuk, hanem külön utasításként (például for ciklusban), érdemesebb a prefix inkrementálást (++i) használni, mert gyorsabb és kevesebb memóriát foglal.

operator++() és operator++(int)

A prefix- és postfix inkrementálás közti különbséget könnyű megjegyezni: ha a ++ előbb van, akkor a növelés is előbb van, ha a ++ a változó mögött szerepel, akkör a növelés később (az inkrementálást/dekrementálást tartalmazó kifejezés kiértékelését követően) történik meg.

Ha csak magát az inkrementáló operátort írjuk le (operandust nem), akkor abból nem derül ki, hogy a prefix- vagy postfix inkrementáló operátorra gondoltunk. A prefix inkrementáló operátort így jelöljük: operator++(), a postfix inkrementáló operátort pedig így: operator++(int).
Esetleg úgy lehet könnyen megjegyezni a kettő  közti különbséget, hogy a postfix inkrementálásnál egy ideiglenes érték tárolása szükséges, ami egy exra (általában int) értéket jelent.

Ezekkel a jelölésekkel osztályok kapcsán, jellemzően iterátorok kapcsán találkozhatunk majd:

Inkrementálás, dekrementálás és undefined behavior

Tekintsük az alábbi példákat:

int i = 0;
std::cout << i << ++i << '\n';
int j = 0;
std::cout << j++ << j << '\n';

Ekkor logikusan azt gondolhatnánk, hogy pl. a std::cout << i << ++i; utasításban először az i meg nem növelt értéke lesz kiírva, aztán pedig a megnövelt értéke, ami persze lehet, hogy egyes esetekben így is van, de ez nem biztos.

A C++17-es szabványt megelőző szabványok szerint fordított forráskód esetén undefined behaviort okoz, ha egyetlen utasításban szerepel egy változóra vonatkozó inkrementálás (vagy dekrementálás), és ugyanabban az utasításban ennek a változónak a neve mégegyszer szerepel.
Például ezek az utasítások undefined behaviourt okoznak:

std::cout << i << ++i << '\n';
std::cout << ++i + i++ << '\n';

Noha a tömbökről csak későbbi tananyagrészben lesz részletesebben szó, fontos, hogy ez az utasítás is undefined behaviourt okozhat (pl. egy for ciklus blokkjában):

array_of_sth[i] = ++i;

A C++17 és újabb szabványokat támogató C++ fordítók esetén ez többnyire meg lett oldva, de ezen tananyag írásának idején (2010-es, 2020-as évek) bőven vannak, akik C++17-es szabványnál régebbi C++ fordítókat használnak, így érdemes a legutóbbi fenti példákat és azokhoz hasonló eseteket (amikor egyetlen utasításon belül szerepel ++valtozo_neve vagy valtozo_neve++ és még egyszer vagy többször a valtozo_neve) kerülni a forráskódban.

Íme egy kis tesztpélda, amit ha különböző fordítókkal (pl. g++, clang, msvc) fordítunk, és futtatunk, akkor jó eséllyel eltérő eredményt kapunk. A kipróbáláshoz segíthenek az online fordítók, pl. a wandbox.org oldalon többféle C++ fordítóval (akár régebbi verziókkal is) kipróbálhatjuk:

//increment undefined behavior test example
#include <iostream>
int main () {
  int i = 0, j = 0;
  std::cout << i++ << ' ' << i++ << ' ' << i++ << '\n';
  std::cout << ++j << ' ' << ++j << ' ' << ++j << '\n';
}

Két változó értékének cseréje

Ideiglenes változóval

Ha két változó értékét ki akarjuk cserélni, az egyik lehetséges megoldás az, hogy létrehozunk egy harmadik, ideiglenes változót, abba elhelyezzük az egyik változó értékét, hogy az ne vesszen el, amikor annak a változónak értékül adjuk a másik változó értékét.
Ha az ideiglenes változót a későbbiek során nem akarjuk használni, akkor akár egy névtelen blokkba is elhelyezhetjük, így csak a blokkon belül lesz elérhető, ameddig a cserét lebonyolítjuk.

//swap example
#include <iostream>

int main() {
  int int_example1 = 128;
  int int_example2 = -256;

  std::cout << "output1: " << int_example1 << ", " << int_example2 << '\n';

  {
    int int_example3 = int_example1;
    int_example1 = int_example2;
    int_example2 = int_example3;
  }

   std::cout << "output2: " << int_example1 << ", " << int_example2 << '\n';
}

A C++ standard library std::swap függvényével

Az std::swap függvényt is használhatjuk (nem csak alaptípusú) változók értékének cseréjéhez, melyet a C++ standard library utility header fájljának includolásával használhatunk.

//std::swap example
#include <iostream>
#include <utility>

int main() {
  double double_example1{3.14};
  double double_example2{2.71};

  std::cout << "output1: " << double_example1 << ", " << double_example2 << '\n';

  std::swap(double_example1, double_example2);

  std::cout << "output2: " << double_example1 << ", " << double_example2 << '\n';
}

Az std::string típus swap tagfüggvényével

Ha két std::string típusú változó értékét szeretnénk kicserélni, akkor használhatjuk az std::string típus swap tagfüggvényét.

#include <iostream>
include <string>

int main() {
  std::string str1{"abc"};
  std::string str2{"def"};

  std::cout << "output1: " << str1 << ' ' << str2 << '\n';

  str1.swap(str2);

  std::cout << "output2: " << str1 << ' ' << str2 << '\n';
}

Egyéb módszerek

Az többféle módszert találhatunk arra vonatkozóan, hogy ideiglenes változó használata nélkül hogyan lehet két változó értékét kicserélni. Például int típus esetén tipikusan kivonás/összeadás, illetve kizáróvagyolással szokták megoldani, de léteznek egyéb módszerek is. Ezekre talán akkor lehet szükség, ha nagyon spórolni kell az erőforrásokkal (pl. beágyazott rendszerekben), de asztali számítógépekre készített programokban teljesen megfelelőek a fentebbi módszerek.

Véletlenszám generálás

A programjainkban alapvető igény lehet, hogy a változóinknak véletlenszerű értéket adjunk. Ebben lehet segítségünkre az alábbi példa, amiben egy véletlenszerűen generált 1 és 100 közti egész számot (az 1-et és 100-at is beleértve) adunk értékül a random_number nevű változónak.
A véletlenszám generálás matematikai háttere egyébként viszonylag bonyolult, de a C++ standard library ebben is nyújt számunkra kész megoldásokat.

//random integral number between 1 and 100
//including 1 and 100
#include <iostream>
#include <random>

int main() {
  std::random_device rnd_device;
  std::mt19937 rnd_generator(rnd_device());
  std::uniform_int_distribution<int> int_dist(1,100);
  int random_number = int_dist(rnd_generator);
  std::cout << random_number << '\n';
}

Hasonló példa, amiben véletlenszerűen generált 0 és 1 közti valós számot (beleértve a 0 és 1 értékeket is) adunk értékül a random_number nevű változónak:

//random number between 0.0 and 1.0
//including 0.0 and 1.0
#include <iostream>
#include <random>

int main() {
  std::random_device rnd_device;
  std::mt19937 rnd_generator(rnd_device());
  std::uniform_real_distribution<double> real_dist(0.0,1.0);
  double random_number = real_dist(rnd_generator);
  std::cout << random_number << '\n';
}

Ha includeoljuk a random header fájlt, többféle random generátort is használhatunk, de az ezek közti különbségre itt most nem térünk ki, mivel ezeknél az egyszerű példáknál nem lényeges, de aki szeretne, a lentebbi linkeken természertesen utánaolvashat.
Amit azért érdemes megemlíteni, hogy 64 bites processzorral rendelkező számítógépeken például az std::mt19937 helyett nyugodtan használhatunk std::mt19937_64-et.
Illetve a legegyszerűbb példákban std::mt19937 helyett esetleg std::default_random_engine-el találkozhatunk még.

Bár függvények készítéséről a tananyag ezen részéig még nem volt szó, a jövőre való tekintettel mégis érdemes megjegyezni, hogyha a fenti kódrészletet egy olyan függvénybe pakoljuk bele, amit nagyon sokszor meghívunk, érdemes a random generátort (jelen példa esetén azt, aminek a típusa std::mt19937, a neve pedig rng) staticként definiálni, vagyis a std::mt19937 rng(random_dev()); sor helyett ezt írni: static std::mt19937 rng(random_dev()); azért, hogy ne kelljen a függvény minden egyes meghívásakor inicializálni a random generátort.

//random number between 1 and 100
//including 1 and 100
//100000 times
#include <iostream>
#include <random>

int generate_rnd_number(const int& intval_begin, const int& intval_end) {
  static std::mt19937 rnd_generator( std::random_device{}());
  std::uniform_int_distribution<int> int_dist(intval_begin,intval_end);
  return int_dist(rnd_generator);
}

int main() {
  for (int i = 0; i < 99999; ++i) {
    std::cout << generate_rnd_number(1, 100) << ' ';
  }
  std::cout << generate_rnd_number(1, 100) << '\n';
}

Továbbá szintén későbbi tananyagrész témáját érintő megjegyzés, hogy az std::random_device esetlegesen kivételt dobhat.

A random generált számok kapcsán esetleg még azt érdemes megjegyezni, hogy a C nyelvből átvett rand függvény használatát sokan kerülendőnek tekintik.

Alapvető matematikai műveletek

Az összeadás, kivonás, szorzás, osztás műveletek viszonylag magától értetődőek, ezek kapcsán talán azt érdemes megemlíteni, hogy az osztás másképp van értelmezve egész- és valós számok esetén (ha két egész típusú dolgot (pl. változót vagy literált) osztunk, akkor egész típusú lesz az eredmény, de ha a két dolog közül legalább az egyik valós típusú, akkor az eredmény is valós típusú lesz) de erről részletesebben az alaptípusok jellemzői tananyagrészben lesz szó.

Hatványozás, gyökvonás

A hatványozás és gyökvonás például a standard library cmath header fájljában található pow függvénnyel végezhető el.

Négyzetre emelés:

//square example
#include <iostream>
#include <cmath>

int main() {
  double variable{};
  std::cout << "Kerem adjon meg egy egesz szamot, vagy valos szamot:\n";
  std::cin >> variable;
  std::cout << "A beolvasott szamertek negyzete: " << pow(variable, 2) << '\n';
}

Hatványozás:

//power example
#include <iostream>
#include <cmath>

int main() {
  double base_number{};
  std::cout << "Kerem adja meg a hatvanyozni kivant szamot:\n";
  std::cin >> base_number;

  double exponent_number{};
  std::cout << "Kerem adja meg a kitevot:\n";
  std::cin >> exponent_number;

  std::cout << "A hatvanyozas eredmenye: " << pow(base_number, exponent_number) << '\n';
}

Gyökvonás:

//square root example
#include <iostream>
#include <cmath>

int main() {
  double variable{};
  std::cout << "Kerem adjon meg egy egesz szamot, vagy valos szamot:\n";
  std::cin >> variable;
  std::cout << "A beolvasott szamertek gyoke: " << sqrt(variable) << '\n';
}

Kerekítés

A C++ standard library cmath header fájljában található ceil függvény felfele kerekíti az adott törtszámot, ha az valamivel nagyobb, mint a hozzá legközelebb lévő, de nála kisebb egész szám (pl. a 2-t nem kerekíti 3-ra, de a 2.01-et már igen), a floor függvény hasonlóképpen lefele kerekít, a round pedig pl. 0.5 és nála nagyobb számokat 1-re kerekíti, de a 0.5-nél kisebb számokat (pl. 0.47-et) 0-ra.

//rounding example
#include <iostream>
#include <cmath>

int main() {
  double a1 = 2.7;
  double a2 = 2.1;
  double a3 = 2.5;
  double b1 = -2.7;
  double b2 = -2.1;
  double b3 = -2.5;

  std::cout << "ceil:\n"
  << a1 << " -> " << ceil(a1) << '\n'
  << a2 << " -> " << ceil(a2) << '\n'
  << b1 << " -> " << ceil(b1) << '\n'
  << b2 << " -> " << ceil(b2) << '\n';
  std::cout.put('\n');

  std::cout << "floor:\n"
  << a1 << " -> " << floor(a1) << '\n'
  << a2 << " -> " << floor(a2) << '\n'
  << b1 << " -> " << floor(b1) << '\n'
  << b2 << " -> " << floor(b2) << '\n';
  std::cout.put('\n');

  std::cout << "round:\n"
  << a1 << " -> " << round(a1) << '\n'
  << a2 << " -> " << round(a2) << '\n'
  << a3 << " -> " << round(a3) << '\n'
  << b1 << " -> " << round(b1) << '\n'
  << b2 << " -> " << round(b2) << '\n'
  << b3 << " -> " << round(b3) << '\n';
}

Egyéb matematikai műveletek

Jason Turner - legkisebb közös többszörös és legnagyobb közös osztó (videó)

string (szöveg) műveletek

Összefűzés (konkatenáció)

string literálok esetén:

Egymás után lévő string literálok összefűzésre kerülnek. Tehát ezen utasítások ugyanazt eredményezik:

std::cout << "abc" "123\n";
std::cout << "abc123\n";
std::cout << "abc" << "123\n";

A fenti példában akár külön sorba is írhatnánk a két string literált, hosszú string literálok esetén ez akár sortördeléshez is hasznos lehet:

std::cout << "abcdefghijklmnopqrstuvwxyz0123456789\n"
"abcdefghijklmnopqrstuvwxyz0123456789\n";

A string literálok összefűzése akkor is így működik, ha egy std::string típusú változónak adjuk értékül az összefűzött string literált:

std::string str = "abc" "123";
std::cout << str << '\n';

Egy string literált és egy karaktert ily módon összefűzni nem lehet:

//error
std::string str = "abc" '\n';

std::string típusú változók esetén:

std::string típusú változók összefűzéséhez a + operátort használhatjuk.

std::string str1 = "abc";
std::string str2 = "123";
std::string str3 = str1 + ", " + str2 + '\n';

A + operátort stringek összefűzésére csak akkor használhatjuk, ha az összefűzendő dolgok között legalább az egyik std::string típusú. A string literálok típusa nem std::string (erről szintén egy későbbi tananyagrészben lesz szó részletesebben).

//error
std::string str = "abc" + "123";

Méret, hossz

string literálok esetén:

Használhatjuk a standard library cstring header fájljában található strlen függvényt:

#include <iostream>
#include <cstring>

int main() {
  std::cout << strlen("Hello World!\n") << '\n';
}

Esetleg a sizeof operátort:

#include <iostream>

int main() {
  std::cout << sizeof("Hello World!\n")-1 << '\n';
}

Ez utóbbi esetén az eredmény eggyel nagyobb lesz, mint az strlen által visszaadott eredmény, mivel a sizeof a string literálok végén lévő lezárókaraktert ('\0') is beleszámolja a méretbe, így ki kell vonnunk egyet a sizeof által visszaadott eredményből, hogy megkapjuk a tényleges méretet.

std::string típusú változók esetén:

A size vagy length tagfüggvényt használhatjuk (mindkettő teljesen ugyanúgy működik):

#include <iostream>
#include <string>

int main() {
  std::string str = "abc123";
  std::cout << "the size of str: " << str.size() << '\n';
}
#include <iostream>
#include <string>

int main() {
  std::cout << "the size of \"Hello World!\\n\": " << std::string("Hello World!\n").size() << '\n';
}
#include <iostream>
#include <string>

int main() {
  std::cout << "Kerem irjon be valamilyen szoveget:\n";
  std::string str;
  getline(std::cin, str);
  std::cout << "A megadott szoveg merete: " << str.size() << '\n';
}

Fontos: a stringek hosszát, méretét bájtban kapjuk meg, ami nem mindig a karakterek számát jelenti. Például az ékezetes karakterek értéke több bájt lehet.

//size is bigger than number of chars
#include <iostream>
#include <string>

int main() {
  std::string str = "áéíóöőúüű";
  std::cout << str.size() << '\n';
}

Ha úgynevezett wstringet (esetleg u16stringet vagy u32stringet) használunk a karakterek tárolásához, akkor a size és length tagfüggvények akkor is a karakterek számát adják vissza, ha vannak ékezetes karakterek a stringben:

//wstring size
#include <iostream>
#include <string>

int main() {
  std::wstring str = L"áéíüöőúüű";
  std::cout << str.size() << '\n';
}

https://stackoverflow.com/questions/905355/how-to-get-the-number-of-characters-in-a-stdstring

https://stackoverflow.com/questions/402283/stdwstring-vs-stdstring

A string egy vagy több karakterének módosítása

A C++ nyelvben az std::string típusú változók karaktereit egyszerű értékadással módosíthatjuk (ezzel ellentétben Javaban ez például nem így van, ott a StringBuilder osztály van ebben a segítségünkre).

Példák:

#include <iostream>
#include <string>

int main() {

  std::string str_example = "hello";
  std::cout << str_example << '\n';

  //modify the first character from h to H
  str_example[0] = 'H';

  std::cout << str_example << '\n';

  //modify the last character from o to zero
  str_example[str_example.length()-1] = '0';

  std::cout << str_example << '\n';
}

Üres-e?

Egy std::string típusú változóról az empty tagfüggvénnyel deríthetjük ki, hogy az éppen aktuális értéke üres string-e. Ez például elágazások és ciklusok esetén lehet hasznos.

#include <iostream>
#include <string>

int main() {
  std::cout.setf(std::ios::boolalpha);

  std::string str_example;
  std::cout << "str_example is empty? " << str_example.empty() << '\n';

  str_example = "something";
  std::cout << "str_example is empty? " << str_example.empty() << '\n';

  str_example = "";
  std::cout << "str_example is empty? " << str_example.empty() << '\n';
}

substr, insert

Ezek a tagfüggvények a következőkre használhatóak:

  • substr: egy std::string bizonyos szakaszának felhasználásához
  • insert: valamilyen szöveg beillesztése egy std::string már meglévő értékébe

substr:

Az alábbi példában a str_example1.substr(1,3) az str_example1 változóban tárolt szövegből a második karaktertől kezdve 3 darab karakternyi szöveget ad vissza, az str_example2.substr(str_example2.size()-3, 3) pedig az str_example2 változóban tárolt szövegből az utolsó 3 karaktert.

Első paraméter: a string hanyadik karakterétől kezdve (a 0 jelenti az első karaktert)
Második paraméter: hány darab karaktert használjunk fel

#include <iostream>
#include <string>

int main() {
  std::string str_example1 = "abdcefghijkl";
  std::string str_example2 = "abdcefghijkl";
  std::cout << str_example1.substr(1,3) + ' ' + str_example2.substr(str_example2.size()-3, 3) << '\n';
}

insert:

Az alábbi példában az str_example1.insert(1,str_example2); utasítás az str_example1 változó értékébe a második karaktertől kezdődően beilleszti az str_example2 értékét.

Első paraméter: hanyadik karaktertől kezdődően (a 0 jelenti az első karaktert)
Második paraméter: mit illesszünk be (string literál vagy std::string)

#include <iostream>
#include <string>

int main() {
  std::string str_example1 = "abdcefghij";
  std::string str_example2 = "0123456789";
  std::cout << "str_example1: " << str_example1 << '\n';
  str_example1.insert(1,str_example2);
  std::cout << "str_example1: " << str_example1 << '\n';
}

Ezekhez hasonló tagfüggvények az erase, replace, append és assign.

std::string típusú változók további tagfüggvényei, és a használatukat bemutató példák például ezen az oldalon találhatóak.

előző tananyagrész: változók, konstansok, literálok
következő tananyagrész: alaptípusok jellemzői

A bejegyzés trackback címe:

https://itkezdoknek.blog.hu/api/trackback/id/tr8516364812

Kommentek:

A hozzászólások a vonatkozó jogszabályok  értelmében felhasználói tartalomnak minősülnek, értük a szolgáltatás technikai  üzemeltetője semmilyen felelősséget nem vállal, azokat nem ellenőrzi. Kifogás esetén forduljon a blog szerkesztőjéhez. Részletek a  Felhasználási feltételekben és az adatvédelmi tájékoztatóban.

Nincsenek hozzászólások.
süti beállítások módosítása