Array struktúrák - a kezdőktől
Struktúra C ++ valahol egy egységet, amely egy egész sor különböző felhasználó által definiált.
Szerkezet - egy összetett adattípusok, épített segítségével a különböző típusok.
Lehetőség van valahogy, hogy megpróbálja meghatározni, de alig a meghatározások egyértelműen azt mutatják, és segít megérteni a kezdő.
A szerkezetek nagyon hasonlít a tömbök.
Ha a tömbök definíció szerint tartalmazhat belsejében önmagában több hasonló elemeket.
Belül szerkezetek leírhatók egy eltérő számú különböző elemeit. És maga a szerkezet egy egyéni adattípust.
// Ebben az esetben, minden egyes ilyen tíz elemek két elemből áll definiált a szerkezeten belül
===========================
Belül a szerkezet ismertetett két különböző típusú definiált változók (int és char). Változók a szerkezeten belül lehet egy eltérő számú, és az egyes elemek megfelelhet a kívánt típust.
Vazhno- A teljes szerkezet az érdeklődés nem a cím szerinti vegyület szerkezetével, és az objektum nevét. Ie Ismertetése után a szerkezet létrehozásához szükséges legalább egy változó a típusú szerkezet, amely egy név.
Ebben a példában, az ilyen változó - obj1. Az ilyen változók nevezzük tárgyakat. Kiderült, hogy van egy változó típusú obj1 MyStruct. Ebben az esetben a fenti változó obj1 kód nyilvánították változó tömb tíz elemét. Mind a tíz elemek van MyStruct típusúak, és ezért minden egyes eleme a tömb áll, ezen elemek, amelyek leírása a szerkezeten belül.
Lehet, hogy valaki segítene, és valaki azt hiszi, egy zavaros és bőbeszédű üres fecsegés. Nem számít.
MyStruct obj1 [10]; // Array tíz szerkezetek. Vagy egyszerűen egy sor szerkezetek.
Mivel a belső szerkezet leírt két változót fogjuk használni a két érték minden egyes eleme a tömb szerkezetek (lásd ma)
Figyelembe véve a fenti kódot, és részletezném értelmében a szükséges struktúrák megérteni, hogy most, amikor az elemek megváltoztatására vagy húzza az elemeket a szerkezet minden egyes eleme a tömb kell kezelni az egyes elemek a szerkezet.
===========================
MyStruct obj1 [10]; // Tíz MyStruct típusú elemek
// Ebben az esetben, minden egyes ilyen tíz elemek két elemből áll definiált a szerkezeten belül
Néha ismert, hogy hány példány tartalmaznia kell egy sor szó, és látható a programozási feladat: „Létrehoz egy tömböt N struktúrák”, stb Az egyszerű problémákat semmi bonyolult. Gyakran diákoknak kínált bevezetni egy N a billentyűzetet, amikor belép ebbe az N létrehozunk egy tömböt struktúrák N elemekkel.
==================
MyStruct * obj1; // obj1 egy mutató MyStruct;
int N; // N a tömb elemeinek számát
cin >> N; // képez részére N
obj1 = új MyStruct [N]; // memória dinamikus a tömb struktúrák N elemek
// Néhány kód
törölni [] obj1; // felszabadítása
==================
Amikor egy tömbszerkezete elemek sokaságát, használható, mint a közös tömb ciklusokat alkalmazunk. Azt hiszem, hogy van értelme, hogy szét az adatokat bemeneti és kimeneti adatok az egyes funkciók. A fenti egyszerű szerkezet jön létre, a következő példa, amely egy adattípus Vegyesbolt.
Élelmiszerbolt egyetlen egész. Az áruház eladni a különböző termékeket. Minden termék nevét, ára van. Az üzletben vannak különböző gyártók, akik eladni árut. Minden eladó megfelelő vásárló, aki megveszi az árut. Ez lehet hosszú és nehéz festeni, hogy mi történik a valóságban. de fogok összpontosítani, hogy ő írta.
Megmagyarázni a fordító, hogy szükségünk van, azt kell vinni, hogy a fentiekkel.
Megtöröm a kódot a fokozatos kifejtését, hogy a legtöbb olvasó már igyekezett megérteni a lényegét.
Minden, ami a boltban lehet csoportosítani néven a kívánt adatokat.
==================
struct Shop
char neve [20]; // Terméknév
float Price; // A termék ára
char prodav [30]; // Az eladó
char pokup [30]; // vevő
int Dátum [3]; // dátuma eladó
>;
==================
Értékesítés dátuma le egy sor három egész szám. A többi változó megfelel különböző típusú, feldolgozásra alkalmas változók
Miután azonosítottuk és leírta a szükséges struktúra létrehozásához szükséges változót, amely a szerkezet típusától nevét. A megadott adat elemek a szerkezet. A következő kód az egész, hogy meg van írva fölött.
=================
#include
/ * Szerkezetét írják * /
struct Shop
char neve [20];
int Price;
char prodav [30];
char pokup [30];
int dátuma [3];
>;
/ * Fő funkció * /
int main ()
<
int N;
cout <<“Введи N: “ ;
cin >> N;
N * M1 = új n [10]; // Kiosztani a tömb szerkezete 10 elemek
törölni [] M1; // felszabadítása
cin. get (); // Várjon gombnyomás
vissza 0;
>
=================
Önmagában nincs ilyen kód sok értelme, ez csak része a felkészülés dolgozik egy sor szerkezetek.
Ezután hozzá kell, hogy járuljon a tömb elemeit egy szerkezetek. Az adatok bemeneti és kimeneti kényelmes, hogy az egyes funkciók gyakran létre egyedi menük egy választott feldolgozási struktúrák. A szerkezet nagyon hasonló a tömb és továbbítjuk a függvény belsejében azonos módon. Akkor használja a mutatót, és meg kell tenni annak érdekében, hogy a függvény tudja a tömb méretét szerkezetek. A méret a tömb struktúra működéséhez meg kell tudni, hogy egy sor szerkezetek feldolgozási ciklusok tudni végpontját annak végrehajtását.
// Először paraméter - pointer Shop
// A második paraméter - a méret a tömb
Az alábbiakban egy teljes kód, amely három funkciót tartalmaz. A fő funkciója, és két funkció kezeli az adatokat. Mivel a feldolgozandó adatokat szolgál egy sor szerkezetek. Egy funkció bemeneti tömb struktúrákat. A második függvény egy tömb struktúrák a képernyőn.
/ * Szerkezetét írják * /
struct Shop
char neve [30];
int Cena;
char Prodav [30];
char Pokup [30];
int Dátum [3];
>;
/ * Funkciók lehetővé teszik az adatokat a képernyőn * /
void ShowData (n * M, int N)
A (int i = 0; i
>
/ * A megadott adatok a szerkezet * /
void GetData (n * M, int N)
cin. figyelmen kívül hagyja ();
A (int i = 0; i
cout <<“НАЗВАНИЕ: “ ; cin. getline ( M [ i ]. Name. 30 );
cout <<“ЦЕНА: “ ; cin>> M [i]. cena;
cin. figyelmen kívül hagyja ();
cout <<“ПРОДАВЕЦ: “ ; cin. getline ( M [ i ]. Prodav. 30 );
cout <<“ПОКУПАТЕЛЬ: “ ; cin. getline ( M [ i ]. Pokup. 30 );
cout <<“ДАТА “;
cin >> M [i]. Dátum [0]; cin. figyelmen kívül hagyja ();
cin >> M [i]. Dátum [1]; cin. figyelmen kívül hagyja ();
cin >> M [i]. Dátum [2]; cin. figyelmen kívül hagyja ();
>
>
/ * Fő funkció * /
void main ()
rendszer ( "CLS");
int N; cout <<“Введите N: “ ; cin>> N;
N * M = új n [N];
GetData (M. N); // adatok bevitelét egy sor szerkezetek
ShowData (M. N); // Print tömb szerkezetek a képernyőn
törölni [] M;
rendszer ( "PAUSE");
>
========================
Érdemes odafigyelni a cin. figyelmen kívül hagyja (). Ha eltávolítja ezt a kódrészletet minden oldalról, kiderül, nem túl kellemes helyzet. Bent a flow maradhat sor karakter, és ez nem egy jó szolgáltatást. Annak elkerülése érdekében, néhány problémát használt CIN .ignore (); Megjegyzem, hogy ez az állítás a fenti kód regisztrált bevitele után nem karakteres adat típusát.
A fenti példa kimeneti szerkezet kényelmes bizonyos esetekben és másokban kényelmetlen. Személy szerint én inkább nézni az adatszerkezet az adatok táblázatban. Dos kis ablak is nem hoz létre egy szép táblázatot, de egy asztal kis asztal felállított egyszerű. Könnyedén létrehozhat egy csipetnyi felülről, ahol regisztrálni a nevét, a hangszórók viszont. És ez könnyen megjelenik egy kis asztal
============================ cin. figyelmen kívül hagyja (); cout <<“ЦЕНА: “ ; cin>> M [i]. cena; cout <<“ПРОДАВЕЦ: “ ; cin. getline ( M [ i ]. Prodav. 30 ); cout <<“ДАТА “ ;
#include
#include
/ * Szerkezetét írják * /
struct Shop
char neve [30];
int Cena;
char Prodav [30];
char Pokup [30];
int Dátum [3];
>;
/ * Funkciók lehetővé teszik az adatokat a képernyőn * /
void ShowData (n * M, int N)
rendszer ( "CLS");
cout <<“НАЗВАНИЕ ЦЕНА ПРОДАВЕЦ ПОКУПАТЕЛЬ ДАТА ПРОДАЖИ” <<“\n\n” ;
A (int i = 0; i
cout <
cout <
cout <
cout <
cout <<“\n” ;
>
/ * A megadott adatok a szerkezet * /
void GetData (n * M, int N)
A (int i = 0; i
cout <<“НАЗВАНИЕ: “ ; cin. getline ( M [ i ]. Name. 30 );
cin. figyelmen kívül hagyja ();
cout <<“ПОКУПАТЕЛЬ: “ ; cin. getline ( M [ i ]. Pokup. 30 );
cin >> M [i]. Dátum [0]; cin. figyelmen kívül hagyja ();
cin >> M [i]. Dátum [1]; cin. figyelmen kívül hagyja ();
cin >> M [i]. Dátum [2]; cin. figyelmen kívül hagyja ();
>
>Kapcsolódó cikkek