Gépelt programozási nyelv. §1 Általános információk a nyelvről. A programtervezés szakaszai. Alkalmazás életciklus modellek Mi a teendő az összes ilyen típusú változóval

Ezek az oktatóanyagok mindenkinek szólnak, akár kezdő a programozásban, akár széleskörű programozási tapasztalattal rendelkezik más nyelveken! Ez az anyag azoknak szól, akik szeretnék megtanulni a C/C++ nyelveket az alapoktól a legbonyolultabb szerkezetekig.

A C++ egy programozási nyelv, ennek a programozási nyelvnek a ismerete lehetővé teszi a számítógép legmagasabb szintű vezérlését. Ideális esetben képes lesz arra késztetni a számítógépet, amit akar. Oldalunk segít elsajátítani a C++ programozási nyelvet.

Telepítés /IDE

Az első dolog, amit meg kell tennie, mielőtt elkezdi tanulni a C++-t, hogy megbizonyosodjon arról, hogy rendelkezik egy IDE-vel – egy integrált fejlesztői környezettel (azzal a programmal, amelyben programozni fog). Ha nincs IDE-je, akkor tessék. Miután eldöntötte az IDE kiválasztását, telepítse azt, és gyakorolja az egyszerű projektek létrehozását.

Bevezetés a C++-ba

A C++ nyelv olyan parancsok halmaza, amelyek megmondják a számítógépnek, hogy mit tegyen. Ezt a parancskészletet általában forráskódnak vagy egyszerűen kódnak nevezik. A parancsok vagy „függvények” vagy „kulcsszavak”. A kulcsszavak (C/C++ fenntartott szavak) a nyelv alapvető építőkövei. A függvények összetett építőelemek, mert egyszerűbb függvények alapján írják őket – ezt látni fogja a legelső programunkban, amely alább látható. Ez a függvénystruktúra egy könyv tartalmához hasonlít. A tartalom megjelenítheti a könyv fejezeteit, a könyvben minden fejezetnek lehet saját, bekezdésekből álló tartalma, minden bekezdésnek saját albekezdése lehet. Bár a C++ számos gyakori függvényt és fenntartott szót tartalmaz, amelyeket használhat, továbbra is szükség van saját függvények írására.

A program melyik részétől kezdődik? A C++-ban minden programnak van egy függvénye, ezt nevezik fő vagy fő függvénynek, a program végrehajtása ezzel a függvénnyel kezdődik. A főfüggvényből bármilyen más függvényt is meghívhatunk, akár mi írtunk, akár – mint korábban említettük – a fordító által biztosítottak.

Tehát hogyan érheti el ezeket a normál funkciókat? A fordítóhoz tartozó szabványos funkciók eléréséhez be kell foglalnia a fejlécfájlt az előfeldolgozó direktívával - #include . Miért hatékony ez? Nézzünk egy példát egy működő programra:

#beleértve << "Моя первая программа на С++\n"; cin.get(); }

Tekintsük részletesen a program elemeit. Az #include egy "előfeldolgozó" direktíva, amely arra utasítja a fordítót, hogy a végrehajtható fájl létrehozása előtt tegye be a programunkba az iostream fejlécfájl kódját. Ha egy fejlécfájlt csatlakoztat a programjához, számos különféle funkcióhoz fér hozzá, amelyeket a programban használhat. Például a cout operátorhoz iostream szükséges. Sor névteret használó std; utasítja a fordítót, hogy olyan függvénycsoportot használjon, amely az std standard könyvtár részét képezi. Ez a sor lehetővé teszi a program számára olyan operátorok használatát is, mint például a cout. A pontosvessző a C++ szintaxis része. Azt mondja a fordítónak, hogy ez a parancs vége. Egy pillanat alatt látni fogja, hogy a C++ legtöbb parancsának lezárására pontosvesszőt használnak.

A program következő fontos sora az int main(). Ez a sor közli a fordítóval, hogy van egy main nevű függvény, és a függvény egész számot ad vissza. A göndör kapcsos zárójelek ( és ) jelzik egy függvény kezdetét (és végét). A göndör kapcsos zárójeleket más kódblokkokban is használják, de mindig egy dolgot jeleznek - a blokk elejét és végét.

A C++ nyelvben a cout objektum szöveg megjelenítésére szolgál (ezt "C out"-nak ejtik). Szimbólumokat használ<< , известные как «оператор сдвига», чтобы указать, что отправляется к выводу на экран. Результатом вызова функции cout << является отображение текста на экране. Последовательность \n фактически рассматривается как единый символ, который обозначает новую строку (мы поговорим об этом позже более подробно). Символ \n перемещает курсор на экране на следующую строку. Опять же, обратите внимание на точку с запятой, её добавляют в конец, после каждого оператора С++.

A következő parancs a cin.get() . Ez egy másik függvényhívás, amely adatokat olvas be a bemeneti adatfolyamból, és várja az ENTER billentyű lenyomását. Ez a parancs megakadályozza, hogy a konzolablak bezáruljon az ENTER billentyű lenyomásáig. Ez időt ad a program kimenetének megtekintéséhez.

A fő függvény végére érve (a záró göndör kapcsos zárójel) programunk a 0 értéket adja vissza az operációs rendszernek. Ez a visszatérési érték azért fontos, mert ennek elemzésével az operációs rendszer meg tudja ítélni, hogy programunk sikeresen befejeződött-e vagy sem. A 0 visszatérési érték sikert jelent, és automatikusan visszaküldésre kerül (de csak az int adattípus esetén; más függvényekhez manuálisan kell visszaadni az értéket), de ha valami mást, például 1-et akarunk visszaadni, akkor ezt meg kell tennünk. kézzel.

#beleértve névtér használata std; int main() ( cout<<"Моя первая программа на С++\n"; cin.get(); return 1; }

Az anyag összevonásához írja be a programkódot az IDE-be, és futtassa. Miután a program lefutott, és látta a kimenetet, kísérletezzen egy kicsit a cout utasítással. Ez segít megszokni a nyelvet.

Mindenképpen kommenteld a programjaidat!

Írjon megjegyzéseket a kódhoz, hogy ne csak saját maga, hanem mások számára is világosabb legyen. A fordító figyelmen kívül hagyja a megjegyzéseket a kód végrehajtásakor, így tetszőleges számú megjegyzést használhat a tényleges kód leírására. Megjegyzés létrehozásához használja a vagy // billentyűt, amely közli a fordítóval, hogy a sor többi része megjegyzés, vagy a /*, majd a */ gombot. Amikor programozni tanul, hasznos, ha megjegyzést tud fűzni a kód egyes részeihez, hogy lássa, hogyan változik a program kimenete. A kommentelés technikájáról részletesen olvashat.

Mi a teendő az ilyen típusú változókkal?

Néha zavaró lehet a több változótípus használata, amikor egyes változótípusok feleslegesnek tűnnek. Nagyon fontos a megfelelő változótípus használata, mivel egyes változók több memóriát igényelnek, mint mások. Ezenkívül a lebegőpontos és a dupla adattípusok a memóriában való tárolásuk, a lebegőpontos számok miatt "pontatlanok", és nem használhatók, ha pontos egész értékeket kell tárolni.

Változók deklarálása C++ nyelven

Változó deklarálásához használja a szintaktikai típust<имя>; . Íme néhány példa a változók deklarációira:

Int num; char karakter; float num_float;

Ehhez egy sorban több azonos típusú változót is deklarálhatunk, mindegyiket vesszővel kell elválasztani.

Int x, y, z, d;

Ha alaposan megnézted, láthattad, hogy a változódeklarációt mindig pontosvessző követi. További információ a „változók elnevezéséről” szóló konvencióról.

Gyakori hibák a változók C++ nyelven történő deklarálásakor

Ha olyan változót próbál meg használni, amely nincs deklarálva, akkor a program nem fordul le, és hibaüzenetet fog kapni. A C++ nyelven minden nyelvi kulcsszó, minden függvény és minden változó megkülönbözteti a kis- és nagybetűket.

Változók használata

Tehát most már tudja, hogyan kell egy változót deklarálni. Íme egy példaprogram, amely bemutatja egy változó használatát:

#beleértve névtér használata std; int main() ( int szám; cout<< "Введите число: "; cin >>szám;<< "Вы ввели: "<< number <<"\n"; cin.get(); }

Nézzük meg ezt a programot, és soronként vizsgáljuk meg a kódját. Az int kulcsszó azt jelzi, hogy a szám egész szám. A cin >> függvény az értéket számmá olvassa be, a felhasználónak a beírt szám után entert kell nyomnia. A cin.ignore() egy olyan függvény, amely beolvas egy karaktert, és figyelmen kívül hagyja azt. A programba rendszereztük a bemenetünket, egy szám beírása után megnyomjuk az ENTER billentyűt, egy szimbólumot, amely szintén a bemeneti adatfolyamba kerül. Nincs rá szükségünk, ezért eldobjuk. Ne feledje, hogy a változó egész típusúként lett deklarálva, ha a felhasználó decimális számot próbál beírni, akkor az csonkolásra kerül (azaz a szám tizedes részét figyelmen kívül hagyja). Próbáljon meg egy decimális számot vagy karaktersorozatot beírni, amikor a példaprogramot futtatja, a válasz a bemeneti értéktől függ.

Vegye figyelembe, hogy változóból történő nyomtatáskor a rendszer nem használ idézőjeleket. Az idézőjelek hiánya jelzi a fordítónak, hogy van egy változó, és ezért a programnak ellenőriznie kell a változó értékét, hogy a változó nevét a végrehajtás során annak értékére cserélje. Több shift utasítás ugyanabban a sorban teljesen elfogadható, és a kimenet ugyanabban a sorrendben történik. Külön kell választani a karakterlánc-literálokat (idézőjelekbe zárt karakterláncok) és a változókat, mindegyiknek meg kell adni a saját shift operátorát<< . Попытка поставить две переменные вместе с одним оператором сдвига << выдаст сообщение об ошибке . Не забудьте поставить точку с запятой. Если вы забыли про точку с запятой, компилятор выдаст вам сообщение об ошибке при попытке скомпилировать программу.

Értékek megváltoztatása, összehasonlítása

Természetesen, függetlenül attól, hogy milyen típusú adatokat használunk, a változók nem igazán érdekesek anélkül, hogy megváltoztatnák értéküket. Az alábbiakban néhány változóval együtt használt operátor látható:

• * szorzás,
• - kivonás,
• + kiegészítés,
• / felosztás,
• = megbízás,
• == egyenlőség,
• > több
• < меньше.
• != egyenlőtlen
• >= nagyobb vagy egyenlő
• <= меньше или равно

A matematikai függvényeket végrehajtó operátorokat a hozzárendelési jeltől jobbra kell használni ahhoz, hogy az eredményt a bal oldali változóhoz rendeljük.

Íme néhány példa:

A = 4*6; // használja a sor megjegyzését és pontosvesszőjét, a egyenlő 24 a = a + 5; // egyenlő az eredeti érték és öt összegével a == 5 // nem rendel ötöt, ellenőrzi, hogy 5-tel egyenlő-e vagy sem

Gyakran használja a ==-t konstrukciókban, például feltételes utasításokban és ciklusokban.

A< 5 // Проверка, a менее пяти? a >5 // Ellenőrizze, hogy egy több mint öt? a == 5 // Ellenőrzés, egy egyenlő öttel? a != 5 // Ellenőrizze, nem egyenlő öttel? a >= 5 // Ellenőrizze, hogy a nagyobb-e vagy egyenlő-e öttel? a<= 5 // Проверка, a меньше или равно пяти?

Ezek a példák nem mutatják túl világosan az összehasonlító jelek használatát, de amikor elkezdjük tanulmányozni a kiválasztási operátorokat, megérti, miért van erre szükség.

A C++ programozási nyelv alapjainak és fortélyainak elsajátítása. Tankönyv gyakorlati feladatokkal és tesztekkel. Szeretnél megtanulni programozni? Akkor jó helyen jár – itt az ingyenes programozói képzés. Akár tapasztalt, akár nem, ezek a programozási leckék segítenek a C++ programok létrehozásának, fordításának és hibakeresésének megkezdésében különféle fejlesztői környezetben: Visual Studio, Code::Blocks, Xcode vagy Eclipse.

Rengeteg példa és részletes magyarázat. Tökéletes kezdőknek (bábuknak) és haladóknak egyaránt. Mindent elmagyaráznak a semmitől a részletekig. Ezek a leckék (200+) jó alapot/alapot adnak a programozás megértéséhez nem csak C++ nyelven, hanem más programozási nyelveken is. És ez teljesen ingyenes!

Szintén szóba kerül egy játék lépésről lépésre történő létrehozása C++ nyelven, az SFML grafikus könyvtár, valamint több mint 50 feladat, amellyel próbára teheti képességeit és tudását C++ nyelven. További bónusz az.

A +20 újraküldéséért a karmának és hálám!

0. számú fejezet. Bevezetés. Kezdő lépések

1. fejezet. C++ alapok

fejezet 2. sz. Változók és alapvető adattípusok C++ nyelven

fejezet 3. sz. Operátorok C++ nyelven

fejezet 4. sz. Hatókör és más típusú változók a C++-ban

fejezet 5. sz. A kód végrehajtásának sorrendje a programban. Hurok és elágazások C++-ban

A számítógépek talán a legsokoldalúbb eszközök, amelyek az emberiség rendelkezésére állnak. Hihetetlen számítások elvégzésére képesek, lehetővé teszik hatalmas mennyiségű információ tárolását, a bolygó teljesen különböző részeit, és ugyanakkor könnyen kicserélhetik azokat, helytől függetlenül. A számítógépek számos mindennapi feladatot megkönnyítenek, és lehetővé teszik számos olyan rutinfolyamat automatizálását, amelyek elvégzése nagyon fárasztó és unalmas lenne az ember számára. A számítógépek sok mindenre képesek, de ennek ellenére a számítógépeknek nincs intelligenciája, ellentétben az emberekkel. Még a legegyszerűbb folyamat automatizálásához is világosan és egyértelműen meg kell mondania a számítógépnek, hogy mit kell tennie. Sajnos teljesen más a nyelvünk és a számítógépes nyelv. Így a gép és az ember között komoly nyelvi akadály van, amelyet valahogy le kell küzdeni, különben a számítógép nem fog megérteni minket. És bár a számítógépek nem értenek meg minket, maguktól nem tesznek semmit. Hatalmas számú programozási nyelvet találtak ki az ember és a számítógép közötti kommunikációs eszközként. A programozási nyelvek segítségével programokat készítünk és a számítógép közvetlenül együttműködik a programokkal. Maguk a programok olyan utasításkészletek, amelyeket a számítógép megért és végrehajthat.

A programok típusai

A számítógéppel való hatékony kommunikáció érdekében, amit szeretnénk, a programozási nyelvek széles skálája létezik.

A projekt típusától függően számos tényezőt kell figyelembe venni a programozási nyelv kiválasztásakor. Íme a legfigyelemreméltóbb tényezők listája:

Összeállítás, értelmezés és JIT összeállítás

A fordítási folyamat lefordítja a programozási nyelven írt kódot a célgép anyanyelvére. Az ezt a folyamatot végrehajtó programot fordítónak nevezzük. A fordítás meglehetősen gyorsan képes futtatni a kódot, különösen, ha a fordító hatékonyan optimalizál. De tény, hogy a kapott kód nem tud működni különböző operációs rendszereken, és a fordítási folyamat eltart egy ideig, és minél több kód, annál hosszabb a fordítási folyamat. Érdemes megjegyezni, hogy a programkód bármilyen változtatásakor le kell fordítani, és csak ezután kell futtatni.

Az értelmezett programozási nyelveket egy interpreter nevű program olvassa be, és ugyanaz a program hajtja végre. Az értelmezett programozási nyelvek különböző operációs rendszereken futhatnak, akárcsak egy tolmács, és nem is hosszú a fordítási idő. De az értelmezett nyelvekkel írt programok általában sokkal lassabban futnak, mint az egyenértékű, lefordított programok.

És végül az úgynevezett on-the-fly összeállítás (vagy JIT-összeállítás). Az ilyen nyelveket a program indításakor gyorsan összeállítják. A JIT nyelveken írt programok általában nincsenek optimalizálva, ami felgyorsítja a fordítási folyamatot, és helyreállítja az egyensúlyt a teljesítmény és a platformok közötti kompatibilitás között.

Magas vagy alacsony programozási szintek

Az alacsony szintű nyelvek többnyire közvetlenül a hardverrel működnek, ezért a legalkalmasabbak eszköz-illesztőprogramok írására. Az illesztőprogramok olyan programok, amelyek a hardvert vezérlik, és közvetlenül hozzáférnek hozzá. Az alacsony szintű nyelven írt programokat azonban általában nehéz más platformokra portolni. Ezért minden operációs rendszerhez ugyanaz az eszköz különböző illesztőprogramokkal érkezik. Az alacsony szintű programozási nyelvek szinte mindig lefordítják.

A magas szintű nyelvekben a teljes hangsúly a nyelv fogalmán van. Vagyis egy ilyen programozási nyelvnek könnyen érthetőnek kell lennie, például az adatokat tömbként, karakterláncként, objektumként stb. kell ábrázolnia. A magas szintű nyelvet általában könnyebb megérteni, mint egy alacsony szintű nyelvet. És általában egy magas szintű nyelven való program fejlesztése sokkal könnyebb és gyorsabb, mint egy alacsony szintű nyelven. Amint láthatja, a programozás különböző szintjei teljesen különböző feladatokra szolgálnak, és nem szabad összehasonlítani a nyelvek funkcionalitását különböző szinteken, ez értelmetlen.

Programozási nyelv adattípus rendszerek

Minden programozási nyelvhez létezik egy specifikáció, amely különböző szabályokat határoz meg, amelyeket a programozási nyelveknek be kell tartaniuk. Egyes nyelvek nem rendelkeznek adattípusokkal, ezért ez nem vonatkozik rájuk. A legtöbb nyelv (beleértve a C++-t is) azonban rendelkezik adattípusokkal, így ezek az információk hasznosak lesznek az Ön számára.

Erős vagy gyenge adattípusú rendszer

A gyenge beviteli rendszer nem támaszt semmilyen korlátozást a programozónak. Amikor azt mondom, hogy „gyenge adatrendszer”, arra gondolok, hogy egy ilyen adatrendszerrel rendelkező nyelv nem szabályozza szigorúan a rendelkezésre álló adattípusokat. Például, ha szám helyett karakterláncot vagy szimbólumot adunk át a szorzási függvénynek, a nem szigorúan begépelt programozási nyelvek végrehajtják az ilyen kódot, bár a szorzás eredménye elveszti értelmét, mivel a karakterlánc nem szorozható szám. Ráadásul ennek az értelmetlen szorzásnak az eredménye megjósolhatatlan lesz. Ha a programozási nyelv szigorúan be van írva, akkor a fordítási szakaszban a fordító hibát jelez, és leállítja a projekt felépítésének folyamatát. Például,

// példaprogram C++-ban #include névtér használata std; int main())( char string = "példa"; int szám = 5; cout<< string * number << endl; // умножаем строку на число }

Ennek eredményeként a fordító hibát jelez:

hiba: érvénytelen „char” és „int” típusú operandusok bináris „operator*”-ra

Megpróbáljuk ugyanezt megtenni egy nem erősen tipizált programozási nyelven - php. Kérjük, vegye figyelembe, hogy még változók deklarálásakor sem kell megadni az adattípust.

A kód végrehajtásának eredménye nulla lesz. Nem történik hiba, bár úgy tűnik, hogy lehetetlen egy karakterláncot számmal megszorozni. De PHP-ben minden lehetséges. A PHP nyelvi fordítója nem fog hibát jelezni, a script működni fog, sőt meg is adja az eredményt, és ha a programunk 1000 sornyi kódból áll, akkor ezt a hibát nehezen fogjuk megtalálni. Ez egy szemléletes példája a „gyenge adattípusú rendszerrel” rendelkező programozási nyelvnek, vagyis az ilyen abszurd műveletek megakadályozása teljes mértékben a programozó vállán nyugszik.

Meghatározott vagy definiálatlan adattípus

Ez a lefordított és értelmezett nyelvekre egyaránt vonatkozik. Sok nyelv megköveteli a változók típusának kifejezett meghatározását, így nincs bizonytalanság, a fordító és a tolmács egyértelműen tudja, mit kell tennie. Egyes programozási nyelvek nem igénylik a változók típusának kifejezett meghatározását. Az adattípus meghatározása automatikusan történik a változó tartalma alapján.

Statikus vagy dinamikus adattípus

Ha a nyelv statikusan van beírva, akkor a fordító/tolmács egyszer típusellenőrzést végez a fordítási/értelmezési folyamat előtt. Ha az adattípus dinamikus, akkor az adattípusok ellenőrzése futás közben történik.

Biztonságos vagy nem biztonságos adattípusú rendszer

Előfordulhatnak olyan helyzetek, amelyek váratlan eredményekhez vagy hibákhoz vezethetnek. A biztonságos nyelvhasználat a lehető legtöbb korlátozást fogja bevezetni annak érdekében, hogy ilyen helyzetek ne forduljanak elő. Míg a nem biztonságos nyelvhasználat minden felelősséget a programozóra hárít.

Ezek a tényezők egy vagy több programozási nyelvet is jellemezhetnek.

Támogatott programozási paradigmák

A programozási paradigmák olyan programozási módszerek vagy módok, amelyeket egy programozási nyelv támogat. Íme a fő paradigmák listája:

Deklaratív paradigma

A deklaratív programozási nyelv nagyobb hangsúlyt fektet a célra, nem pedig a cél elérésének eszközére. Elég megjelölni, hogy mit kell elérni, de nem szükséges jelezni, hogy milyen eszközöket kell alkalmazni. Ez a paradigma megakadályozza a nem kívánt mellékhatásokat, amelyek saját kód írásakor fordulhatnak elő.

Funkcionális paradigma

A funkcionális programozás a deklaratív programozás egy részhalmaza, amely matematikai egyenletek és függvények segítségével próbálja megoldani a problémákat. A funkcionális programozás a változókat és az objektumokat nem megosztott adatként kezeli, ellentétben a kötelező nyelvekkel.

Általános paradigma

Az általános programozás az algoritmusok írására összpontosít a meghatározandó adattípusok szempontjából. Vagyis ugyanaz az algoritmus különböző típusú adatokkal működhet. Ez a megközelítés nagyon hatékony eszköz lehet, de csak akkor, ha jól alkalmazzák.

Imperatív paradigma

A kötelező nyelvek lehetővé teszik a programozók számára, hogy rendezett listát adjanak a számítógépnek a feladat elvégzéséhez szükséges utasításokról. Az imperatív programozási nyelveket szembeállítják a deklaratív programozási nyelvekkel.

Strukturális paradigma

A strukturális programozási nyelvek célja valamilyen kód – hierarchikus struktúra – biztosítása. Ha a kód szerkezete jól látható, az utasítások végrehajtási sorrendje intuitív módon egyértelművé válik. Az ilyen nyelvek általában visszatartják a kód egyik részéből a másikba való „ugrást”, például a jól ismert goto operátort, amely a C és C++ nyelvekben van definiálva.

Eljárási paradigma

Az eljárási programozási nyelv olyan strukturált programozási nyelvekre utal, amelyek támogatják az eljárás vagy szubrutin koncepcióját.

Objektumorientált paradigma

Az objektum-orientált programozás (néha rövidítve OOP) a strukturált programozás egy részhalmaza, amely a programokat "objektumokkal" fejezi ki. Ez a paradigma lehetővé teszi a kód újrafelhasználását, és ez a megközelítés meglehetősen egyszerű megérteni.

Szabványosítás

Van a nyelveknek hivatalos szabványa? A szabványosítás nagyon fontos annak biztosításához, hogy a különböző fordítók/tolmácsok konfliktusmentesen megértsék a programot. Egyes nyelveket az Amerikai Nemzeti Szabványügyi Intézet (ANSI), másokat a Nemzetközi Szabványügyi Szervezet (ISO) szabványosított. Minden programozási nyelvet szabványosítani kell, különben nem lesz egyetértés abban, hogy mi a helyes és mi a helytelen a szintaxisban.

Jellemezzük a C++ programozási nyelvet

Most, hogy megvizsgáltuk a programozási nyelvek főbb jellemzőit, határozzuk meg, hogy a C++ programozási nyelv mely tényezőket elégíti ki.

A C++ egy ISO szabványos programozási nyelv.

A C++-nak egy ideig nem volt hivatalos szabványa, azonban 1998 óta a C++-t egy ISO bizottság szabványosította.

C++ lefordított nyelv.

A C++ közvetlenül gépi kódra fordít, így a világ egyik leggyorsabb nyelve.

A C++ egy erősen tipizált nyelv.

A C++ feltételezi, hogy a programozó tudja, mit csinál, és hihetetlen számú lehetőséget enged meg, amelyeknek csak a képzelet szab határt.

A C++ támogatja a statikus és dinamikus adattípusokat.

Így az adattípus-ellenőrzés elvégezhető fordítási vagy futási időben. És ez ismét bizonyítja a C++ rugalmasságát.

A C++ számos paradigmát támogat.

A C++ támogatja az eljárási, általános és objektumorientált programozási paradigmákat, és sok más paradigmát.

A C++ egy hordozható programozási nyelv.

A világ egyik leggyakrabban használt nyelveként és nyílt nyelvként a C++ fordítóprogramok széles választékával rendelkezik, amelyek különféle platformokon futnak. A C++ Standard Library kód számos platformon futni fog.

A C++ teljes mértékben kompatibilis a C nyelvvel

C++-ban használhat C-könyvtárakat, és ezek megfelelően fognak működni.

Ez a cikk általánosságban tárgyalja a scanf() függvényt, anélkül, hogy egy adott szabványra hivatkozna, ezért itt minden C99, C11, C++11, C++14 szabvány adatai szerepelnek. Lehetséges, hogy egyes szabványokban a funkció a cikkben bemutatott anyagtól eltérően működik.

scanf C függvény - leírás

A scanf() az stdio.h(C) és a cstdio(C++) fejlécfájljában található függvény, amelyet a program formázott bemenetének is neveznek. A scanf beolvassa a karaktereket a szabványos bemenetről (stdin), és a formátumnak megfelelően átalakítja, majd a megadott változókba írja. A formátum azt jelenti, hogy az adatok fogadásakor egy bizonyos formára redukálódnak. Így a scanf C függvény leírása:

scanf("%formátum", &változó1[, &változó2,[…]]),

ahol a változókat címként adják át. A változók ilyen módon történő átadásának oka nyilvánvaló: működése eredményeként a hibák meglétére utaló értéket ad vissza, így a változók értékének megváltoztatásának egyetlen módja a cím szerinti átadás. Ezenkívül ennek a módszernek köszönhetően a függvény bármilyen típusú adatot képes feldolgozni.

Egyes programozók olyan függvényeket hívnak meg, mint a scanf() vagy a printf() eljárások a más nyelvekkel való analógiák miatt.

A Scanf lehetővé teszi az összes alapvető nyelvtípus megadását: char, int, float, string stb. String típusú változók esetén nincs szükség a címjel - „&” feltüntetésére, mivel a string típusú változó egy tömb, neve pedig a tömb első elemének címe a számítógép memóriájában.

Adatbeviteli formátum vagy vezérlőkarakterlánc

Kezdjük azzal, hogy a leírásból nézzünk meg egy példát a scanf C függvény használatára.

#beleértve int main() ( int x; while (scanf("%d", &x) == 1) printf("%d\n", x); return 0; //követelmény linux rendszerekhez )

A beviteli formátum a következő négy paraméterből áll: %[*][width][modifiers] type. Ebben az esetben a „%” jel és a típus kötelező paraméterek. Vagyis a minimális formátum így néz ki: „%s”, „%d” és így tovább.

Általában a karakterláncot alkotó karakterek a következőkre oszlanak:

• formátumspecifikátorok - minden, ami a % szimbólummal kezdődik;
• elválasztó vagy szóköz karakterek – ezek közé tartozik a szóköz, a tabulátor (\t), az új sor (\n);
• a szóközön kívül más karaktereket.

Lehet, hogy a funkció nem biztonságos.

Használja a scanf_s() függvényt a scanf() helyett.

(A Visual Studio közzétette)

Típus- vagy formátumspecifikátorok, konverziós karakterek vagy vezérlőkarakterek

A scanf C leírásának tartalmaznia kell legalább egy formátummeghatározót, amely a "%" jellel kezdődő kifejezések végén található. Megmondja a programnak, hogy milyen típusú adatokat várjon bevitelkor, általában a billentyűzetről. Az összes formátum-specifikáció listája az alábbi táblázatban található.

Karakterek a formátumban

Csillag (*)

A csillag (*) egy zászló, amely azt jelzi, hogy a hozzárendelési műveletet el kell tiltani. Közvetlenül a „%” jel után egy csillag kerül. Például,

Scanf("%d%*c%d", &x, &y); //figyelmen kívül hagyja a két egész szám közötti karaktert. scanf("%s%*d%s", str, str2); //figyelmen kívül hagyja a két karakterlánc közötti egész számot.

Vagyis ha beírja a „45-20” sort a konzolba, a program a következőket fogja tenni:

1. Az "x" változó értéke 45 lesz.
2. Az "y" változó értéke 20 lesz.
3. És a mínuszjelet (kötőjel) a „-” figyelmen kívül hagyja a „%*c”-nek köszönhetően.

Szélesség (vagy mező szélessége)

Ez egy egész szám a „%” jel és a formátummeghatározó között, amely megadja az aktuális olvasási művelet során beolvasandó karakterek maximális számát.

Néhány fontos szempontot érdemes szem előtt tartani:

1. A scanf leáll, ha határoló karakterrel találkozik, még akkor is, ha nem számolt 20 karaktert.
2. Ha a bemenet több mint 20 karaktert tartalmaz, ezek közül csak az első 20 kerül beírásra az str változóba.

Típusmódosítók (vagy precíziós)

Ezek speciális jelzők, amelyek módosítják a bemenetre várt adatok típusát. A zászló a típusmeghatározótól balra van megadva:

• L vagy l (kis L) Ha "l"-t használunk a d, i, o, u, x specifikációkkal, a zászló jelzi a programnak, hogy long int típusú bemenetet várjon. Ha „l”-t használunk az e vagy az f specifikátorral, a jelző jelzi a programnak, hogy double típusú bemenetre kell számítania. Az "L" használata azt mondja a programnak, hogy long double típusú érték várható. Ha az „l” karaktert a „c” és „s” specifikációkkal együtt használja, a program megmondja, hogy a wchar_t típusú kétbájtos karakterek várhatók. Például "%lc", "%ls", "%l".
• h a short típust jelző zászló.
• hh – azt jelzi, hogy a változó egy előjeles char vagy előjel nélküli char típusú értékre mutató mutató. A zászló a d, i, o, u, x, n specifikációkkal használható.
• ll (két kis L) - azt jelzi, hogy a változó egy signed int vagy unsigned long long int típusú értékre mutató mutató. A zászlót a következő specifikációkkal használjuk: d, i, o, u, x, n.
• j - azt jelzi, hogy a változó egy mutató az intmax_t vagy uintmax_t beírására az stdint.h fejlécfájlból. A következő jellemzőkkel együtt használjuk: d, i, o, u, x, n.
• z - azt jelöli, hogy a változó egy mutató a size_t típusra, amelynek definíciója az stddef.h. A következő jellemzőkkel együtt használjuk: d, i, o, u, x, n.
• t - azt jelzi, hogy a változó egy mutató a ptrdiff_t beírására. Ennek a típusnak a definíciója az stddef.h fájlban található. A következő jellemzőkkel együtt használjuk: d, i, o, u, x, n.

A módosítókkal ellátott kép áttekinthetőbben megjeleníthető táblázat formájában. A scanf C leírása világosabb lesz a programozók számára.

Más karakterek

A formátumban talált karakterek el lesznek vetve. Érdemes megjegyezni, hogy a szóköz vagy határoló karakterek (újsor, szóköz, tabulátor) jelenléte a vezérlőkarakterláncban a függvény eltérő viselkedéséhez vezethet. Az egyik verzióban a scanf() minden határoló elmentése nélkül olvassa, amíg a határolótól eltérő karakterrel nem találkozik, míg egy másik verzióban a szóközök (csak azok) nem számítanak, és a "%d + %d" kifejezés egyenértékű. "% d+%d"-re.

Példák

Nézzünk meg néhány példát, amelyek segítenek átgondolni és pontosabban megérteni a függvény működését.

Scanf("%3s", str); //ha a konzolban beírja az „1d2s3d1;3” sort, csak az „1d2” lesz kiírva a str scanf("%dminus%d", &x, &y); //a két szám közötti mínusz karakterek el lesznek vetve scanf("%5", str); //a karakterek addig kerülnek az str-be, amíg nem lesz belőlük 5, és a karakterek 0 és 9 közötti számok. scanf("%lf", &d); //várt bemenet double scanf("%hd", &x); //számos típusú short scanf("%hu", &y); //számos unsigned típusú rövid scanf("lx", &z); //típus várt száma long int

A megadott példákból láthatja, hogyan változik a várt szám különböző szimbólumok használatával.

scanf C - leírás kezdőknek

Ez a rész hasznos lesz kezdőknek. Gyakran nem annyira a scanf C teljes leírására van szükséged, mint inkább a funkció működésének részleteire.

• A funkció kissé elavult. A különböző verziójú könyvtárakban számos különböző megvalósítás létezik. Például a továbbfejlesztett scanf S C funkció, amelynek leírása megtalálható a Microsoft honlapján.
• A formátumban szereplő specifikációk számának meg kell egyeznie a függvénynek átadott argumentumok számával.
• A bemeneti adatfolyam elemeit csak határoló karakterekkel szabad elválasztani: szóköz, tabulátor, újsor. Vessző, pontosvessző, pont stb. – ezek a karakterek nem határolói a scanf() függvénynek.
• Ha a scanf határoló karaktert talál, a bevitel leáll. Ha egynél több változót kell beolvasni, a scanf a következő változó olvasására lép.
• A bemeneti adatok formátumának legkisebb eltérése a program előre nem látható eredményéhez vezet. Jó, ha a program csak hibával ér véget. De gyakran a program továbbra is működik, és hibásan csinálja.
• scanf("%20s ...", ...); Ha a bemeneti adatfolyam meghaladja a 20 karaktert, a scanf beolvassa az első 20 karaktert, és vagy befejezi, vagy továbblép a következő változó olvasásához, ha meg van adva. A következő scanf hívás ott folytatja a bemeneti adatfolyam olvasását, ahol az előző scanf hívás abbamaradt. Ha az első 20 karakter olvasása közben határoló karaktert találunk, a scanf leáll, vagy továbbmegy a következő változó olvasására, még akkor is, ha nem olvasott be 20 karaktert az első változónál. Ebben az esetben az összes megszámlálhatatlan karakter a következő változóhoz lesz csatolva.
• Ha a beolvasandó karakterkészlet "^" jellel kezdődik, akkor a scanf addig olvassa az adatokat, amíg nem találkozik egy határoló karakterrel vagy a készlet egy karakterével. Például a "%[^A-E1-5]" addig olvassa az adatokat az adatfolyamból, amíg a nagybetűs angol karakterek egyikét A-tól E-ig vagy az 1-től 5-ig terjedő számok valamelyikét meg nem találja.
• A scanf C függvény a leírtak szerint a változók sikeres bevitelének számával egyenlő számot ad vissza. Ha a scanf 3 változót ír, akkor a függvény sikeres működésének eredménye a 3-as szám visszatérése lesz. Ha a scanf nem tudott változót írni, akkor az eredmény 0 lesz. És végül, ha a scanf nem tudott dolgozni valamiért az eredmény EOF lesz.
• Ha a scanf() függvény nem fejezte be megfelelően a munkáját. Például scanf("%d", &x) - egy számot vártak, de szimbólumok érkeztek bemenetként. A következő scanf() hívás a bemeneti adatfolyam azon pontjától indul, ahol az előző függvényhívás véget ért. A probléma megoldásához meg kell szabadulnia a problémás karakterektől. Ezt megteheti például a scanf("%*s") meghívásával. Vagyis a függvény beolvas egy karakterláncot, és kidobja. Ezzel az ügyes módon folytathatja a szükséges adatok bevitelét.
• A scanf() egyes megvalósításai nem teszik lehetővé a "-" használatát a vizsgálandó karakterkészletben.
• A „%c” megadó minden karaktert beolvas az adatfolyamból. Vagyis a határoló karaktert is olvassa. A határoló karakter kihagyásához és a kívánt karakter olvasásának folytatásához használja a „%1s”-t.
• A „c” specifikáció használatakor elfogadható a „%10c” szélesség használata, de ekkor át kell adni egy char típusú elemek tömbjét változóként a scanf függvénynek.
• A „%” jelentése „az angol ábécé összes kis betűje”, a „%” pedig egyszerűen 3 karaktert jelent: „z”, „a”, „-”. Más szóval, a "-" karakter csak akkor jelent tartományt, ha két, a megfelelő sorrendben lévő karakter között jelenik meg. Ha a "-" egy kifejezés végén, elején vagy a karakterek rossz sorrendjében van annak mindkét oldalán, akkor egyszerűen egy kötőjelet jelent, nem pedig egy tartományt.

Következtetés

Ezzel be is fejeződik a scanf C leírása. Ez egy jó kényelmi funkció kisméretű programokban való munkavégzéshez és procedurális programozási módszerekhez. A fő hátrány azonban a scanf használatakor előforduló előre nem látható hibák száma. Ezért a legjobb, ha programozáskor a scanf C leírását a szeme előtt tartja. A nagy professzionális projektekben az iostreameket azért használják, mert magasabb szintű képességekkel rendelkeznek, jobban képesek elkapni és feldolgozni a hibákat, és jelentős mennyiségű információval is dolgoznak. Azt is meg kell jegyezni, hogy a scanf C orosz nyelvű leírása számos online forrásban elérhető, valamint példák a használatára, a funkció kora miatt. Ezért ha szükséges, mindig megtalálhatja a választ a tematikus fórumokon.