A | B | C | D | E | F | G | H | CH | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
C | |
Paradigma | imperatív (procedurális), strukturált |
Jellemző kiterjesztés | .h, .c |
Megjelent | 1972[1] |
Tervező | Dennis Ritchie |
Fejlesztő | Dennis Ritchie & Bell Labs |
Típusosság | statikus, gyenge |
Fordítóprogram | GCC, MSVC, Borland C, Watcom C |
Megvalósítások | Clang, GCC, Intel C, MSVC, Turbo C, Watcom C |
Hatással volt rá | B (BCPL,CPL), ALGOL 68, Assembly, Pascal |
Befolyásolt nyelvek | awk, csh, C++, C#, ObjC, BitC, D, Concurrent C, Java, Javascript, Rust |
Operációs rendszer | |
Weboldal |
A C egy általános célú programozási nyelv, melyet Dennis Ritchie fejlesztett ki Ken Thompson segítségével 1969 és 1973 között a UNIX rendszerekre az AT&T Bell Labs-nál.[2] Idővel jóformán minden operációs rendszerre készítettek C fordítóprogramot, és a legnépszerűbb programozási nyelvek egyikévé vált. Rendszerprogramozáshoz és felhasználói programok készítéséhez egyaránt jól használható. Az oktatásban és a számítógép-tudományban is jelentős szerepe van.
A C minden idők legszélesebb körben használt programozási nyelve,[3][4] és a C fordítók elérhetők a ma elérhető számítógép-architektúrák és operációs rendszerek többségére. Elterjedésében fontos szerepet játszott a RISC technológia. A sokféle processzorhoz operációs rendszerekre volt szükség, és az eleve C-ben írt Unix volt a legkönnyebben portolható.
Történet
Korai fejlesztések
A kezdeti fejlesztések az AT&T berkein belül történtek 1969 és 1973 között. A legkreatívabb időszak, Ritchie-nek köszönhetően 1972-ben volt. Azért lett „C” a nyelv neve, mert egy korábbi, „B” nevű programozási nyelv sok tulajdonságát „örökölte”. A leírások különböznek a „B” név forrását illetően: Ken Thompson írt egy programozási nyelvet, a BCPL-t, de írt egy Bon nevűt is, a feleségéről (Bonnie-ról) elnevezve.
Az 1973-as évben a C nyelv elég hatékonnyá vált, így a UNIX rendszermag legnagyobb részét, melyek PDP-11/20 assembly nyelven íródtak, újraírták C-ben. Ez volt az egyik első operációs rendszer rendszermag, mely nem assembly nyelven íródott, korábbiak, a Multics PL/I-ben íródott, a TRIPOS BCPL-ben.
K&R C
1978-ban megjelent a Dennis Ritchie és Brian Kernighan nevével fémjelzett A C programozási nyelv c. könyv első kiadása. Ez a könyv, melyet a C programozók csak K&R néven emlegettek, sokáig szolgált a nyelv formai leírásának forrásaként. A C nyelvnek az a verziója, melyet leírt, az a „K&R C” nyelv. (A könyv második kiadása az „ANSI C” szabványt írta le, lásd alább.)
A K&R a nyelv következő tulajdonságait vezette be:
struct
adattípuslong int
adattípusunsigned int
adattípus- A
=+
típusú értékadó operátorokat a+=
formára változtatták. (A 'var =- érték
' túlságosan hasonlított a 'var = -érték
'-hez, bár hatásuk egészen más.)
A K&R C a nyelv legalapvetőbb részének tekinthető, melyet egy C fordítónak mindenképpen ismernie kell. Sok éven keresztül, még az ANSI C bevezetése után is, a „legnagyobb közös osztó” volt a K&R, melyet a C programozók használtak, ha a legnagyobb mértékű (forrás szintű) kompatibilitásra volt szükség, hiszen nem minden C fordító támogatta a teljes ANSI C-t és a megfelelően megírt K&R C (forrás)kód megfelelt az ANSI C szabványnak is.
A K&R C megjelenése utáni években, sok „nem hivatalos” kiegészítés látott napvilágot, melyet az AT&T és néhány másik cég fordítói is támogattak.
Ilyen változtatások voltak többek közt:
void
típusú függvény ésvoid *
adattípus- függvények, melyek
struct
vagyunion
típusokat voltak képesek visszaadni (return) - különböző struktúráknak lehetnek azonos nevű mezői (korábban az összes struktúra összes mezője egy közös névtéren osztozott!)
- struktúra típusú változók értékadása (korábban ezt csak a
memcpy
függvénnyel lehetett megtenni) const
definíció, az érték írásvédettségéhez- szabvány programkönyvtár (library), mely a különböző cégek leggyakrabban támogatott függvényeit tartalmazta
- felsorolások (
enum
) - az un. „single-precision” (egyes pontosságú)
float
adattípus
ANSI C és ISO C
Az 1970-es évek vége felé, a C kezdte felváltani a BASIC nyelvet a személyi számítógépeken. Személyi számítógépekre is átültették az 1980-as években, így a C nyelv népszerűsége ugrásszerűen emelkedni kezdett. Ugyanebben az időben Bjarne Stroustrup és társai a Bell Labs-nél elkezdtek dolgozni objektumorientált nyelvi elemek hozzáadásán a C nyelvhez. A nyelv, amit készítettek a C++ nevet kapta, ez ma a legelterjedtebb programozási nyelv a Microsoft Windows operációs rendszereken, míg a C a UNIX világban megőrizte népszerűségét.
1983-ban az Amerikai Nemzeti Szabványügyi Hivatal (angolul: American National Standards Institute, röviden ANSI) megalakította az X3J11 bizottságot, hogy létrehozzanak egy egységes (szabvány) C definíciót. A hosszú és fáradságos folyamat végén 1989-ben elkészült a szabvány (egy évvel az első C++ ANSI szabvány után!) és jóváhagyták mint: ANSI X3.159–1989 „A C programozási nyelv”. A nyelvnek ezt a verzióját nevezik ANSI C-nek. 1990-ben az ANSI C szabványt (néhány apróbb módosítással) átvette a Nemzetközi Szabványügyi Szervezet (angolul: International Organization for Standardization, röviden ISO) mint ISO/EC 9899:1990.
Az ANSI C szabványosítás egyik célja az volt, hogy a K&R C-ből és a nem hivatalos bővítésekből egy egységeset alakítson ki. Belevettek azonban számos új megoldást is, mint például függvény prototípust (a C++ nyelvből) valamint egy jobban alkalmazható (fejlettebb) előfordítót (preprocesszor).
ANSI C-t szinte minden fordító támogat. A legtöbb C kód, mely manapság íródott, az ANSI C-n alapul. Bármilyen program, amely a szabvány C-ben íródott, helyesen működik bármely platformon, amelyen szabványos C létezik. Vannak azonban programok, melyek csak adott platformon vagy adott fordítóval fordíthatók le, a használt nem szabvány függvénygyűjtemények miatt (például grafikus függvények) és vannak olyan fordítók, melyek nem támogatják alapértelmezésben az ANSI C szabványt.
C99
Az ANSI szabványosítási folyamatot követően, a C nyelv viszonylag állandó maradt, míg a C++ fejlődött. Új C verzió, 1995-ben az első normatív kiegészítéssel jött létre, de ezt a változatot ritkán használják. A szabványt átdolgozták az 1990-es években és ebből lett az ISO 9899:1999 1999-ben. Ez a szabvány „C99” néven vált ismertté, majd 2000 márciusában bekerült az ANSI szabványok közé is.
C99 új tulajdonságai, többek közt:
- inline függvények
- változók definiálási helyére vonatkozó szabályai enyhítése (hasonlóképpen, mint C++-ban)
- új adattípusok, például:
long long int
, hogy a 32bitről a 64bitre való átállást megkönnyítsék, explicitbool
(stdbool.h
) és acomplex
(complex.h
) típus. - változó méretű tömbök
- hivatalosan is bevezették az egysoros kommentár jelölést
//
(a C++-ból) - több új függvény, mint például:
snprintf()
- több új „header” állomány, mint például az
inttypes.h
, amely rögzített méretű integer típusokat definiál:int8_t, int16_t, int32_t, int64_t
, illetve ezek előjel nélküli változatait.
Az érdeklődés a C99 új tulajdonságainak támogatásával kapcsolatban eléggé vegyes. Míg GCC (GNU Compiler Collection, korábban GNU C Compiler) és más fordítók támogatják a C99 újdonságait, addig a Microsoft és Borland által forgalmazottak nem, és ez a két cég nem is foglalkozik a C99 jövőbeli támogatásának lehetőségével jelenleg.
C11
2007-ben kezdődött a munka a C sztenderd egy másik revíziójával kapcsolatban, amit informálisan "C1X"-nek hívtak egészen addig, míg hivatalosan is nem publikálták 2011. december 8-án. A C sztenderdek tanácsa elfogadta az ajánlásokat az új lehetőségek limitált beépítésére, amelyeket még nem kezdtek el tesztelni létező implementáción.
A C11 sztenderd számos új lehetőséget adott hozzá a C és könyvtárakhoz, beleértve a típus generikus makrókat, anonim struktúrákat, javított Unicode támogatást, atomi operációkat, többszálúságot és határ ellenőrző függvényeket. Továbbá elkészítették a létező C99 könyvtár néhány portolását, és javították a kompatibilitást a C++-szal.
C18
A C18-at 2018 júniusában adták ki, ami a C programozási nyelv aktuális szabványa. Nem vezetett be új nyelvi elemeket, csak technikai korrekciókat, pontosításokat tartalmaz a C11-hez képest. Az __STDC_VERSION__ macro 201710L-nek van definiálva.
Beágyazott C
Rendszerint a beágyazott rendszerekhez nem szabványosított kiterjesztéseket használnak, hogy lehetővé tegyék az egzotikusabb funkciók használatát, mint pl. fix pontos aritmetikát, különböző memória bankok használatát és alap I/O műveleteket.
2008-ban a C szabványügyi bizottság publikált egy technikai beszámolót, hogy kiterjessze a C programozási nyelvet ezekkel a lehetőségekkel, az által, hogy közös szabványt biztosít. Ez rengeteg funkciót foglal magába ami nem része a normál C-nek, mint pl. fix pontos aritmetika, nevesített címtartományok és alapvető I/O hardver címzések.
A C nyelv jellemzői
- strukturált
- szabványos: minden platformon van fordítóprogramja, a kód a forrásprogram szintjén hordozható
- a C-program rendkívül hatékony gépi kódra fordul le.
A nyelv makrónyelv abban az értelemben, hogy a C-fordító assembly nyelvre fordít, a programozónak azonban egyetlen assembly sort sem kell leírnia (sőt, nem is kell tudnia erről).
A C strukturált programnyelv: bármelyik utasítás helyén állhat blokk, mely {
és }
jelek közé zárt tetszőleges típusú és számú utasításból állhat. A blokkok egymásba skatulyázhatók. A függvények utasításai blokkban helyezkednek el. A C-program belépési pontja a main
nevű függvény, mely az operációs rendszertől kapja a híváskor megadott paramétereket, és annak adja vissza az (egész típusú) visszatérési értékét.
Formai szabályok
A nyelv utasításai a preprocesszor-utasítások kivételével szabad formátumúak: ahol egy helyköz megengedett, ott akárhány helyköz, tabulátor, új sor lehet. A nyelv szavai (utasításnevek, változónevek, számok, műveleti jelek stb.) között lehet helyköz, de nem kötelező. Az utasítások pontosvesszővel végződnek. Az üres utasítás az előző utasítás vége után tett pontosvessző. A folytatósor – a sor végi \
– a szabad formátum miatt csak preprocesszor-utasításokban használatos.
A megjegyzéseket (kommenteket) /*
és */
közé kell zárni, és szabvány szerint nem ágyazhatók egymásba, bár sok fordítóprogram mégis megengedi. Az ANSI C-től kezdve használható a //
, mely a sor végéig tartó megjegyzést vezet be (a C++-hoz hasonlóan). Hosszabb megjegyzéseket a #if 0
...#endif
közé is lehet tenni; ezek – lévén preprocesszor-utasítások – egymásba ágyazhatók.
C-ben a nevek kis- és nagybetűkből, számjegyekből és aláhúzásból állhatnak, számjegy nem lehet az első karakter. A kis- és nagybetűk különbözőnek számítanak. A kialakult szokás szerint a változó- és függvénynevekben kisbetűket használunk, a preprocesszor-utasításokban rendszerint nagybetűket.
Utasítástípusok
A preprocesszor utasítások az assembly nyelvek makróihoz hasonlítanak: a fordítás első menetében „normál” C-utasításokká fordulnak le.
Az aritmetikai utasítások nagyon különböznek a többi programozási nyelvben megszokott értékadó utasításoktól. Ezt az aritmetikai utasítást vette át a C++ és a Java.
A nyelvnek nincs input/output utasítása, ezt szabványos könyvtári függvények végzik.
A végrehajtható utasítások (aritmetikai és vezérlő utasítások) függvényen belül, blokkban helyezkednek el. A C-program preprocesszor-utasításokból, deklarációkból és függvényekből áll.
Egy egyszerű példaprogram
#include <stdio.h> // preprocesszor utasítás
int main() // függvénydefiníció, egyúttal a program belépési pontja, ezúttal nincs paramétere
{ // blokk kezdete
int i; // deklaráció
for (i=1; i <= 3; i++) // vezérlő (ciklus-) utasítás. A ++ egyváltozós értékadó művelet: eggyel növeli i-t.
{ // újabb blokk-kezdet
printf("Haho\n"); // I/O műveletet végző könyvtári függvény. A konzolra ír.
// A stringkonstansot <code>"</code>-k közé kell zárni. A <code>\n</code> az új sor jele a stringben.
} // a belső blokk vége
return 0; // vezérlő utasítás: kilépés a függvényből. A <code>main</code> értékét az operációs rendszer kapja meg
// Windows-ban az <code>errorlevel</code>, Unixban a <code>$?</code> változóban.
} // main blokkjának vége
A program fordítása linuxban (ha a fenti kódot a haho.c
file-ba tettük):
gcc -o haho haho.c
Futtatás:
./haho
Kimenet:
Haho Haho Haho
A C-programozók a fenti ciklusutasítást for (i=0; i < 3; i++)
alakban szokták leírni, mert a tömbök indexelése 0-tól kezdődik a C-ben. A példában a kettő teljesen azonos.
Adattípusok
Egyszerű típusok
char | 8 |
short | 16 |
int | 16 |
long | 32 |
long long | 64 |
float | 32 |
double | 64 |
long double | 80 |
- char: egy karakter tárolására képes memóriaterület. Karakterkonstansok (pl. az A betű különböző alakokban):
'A'
,65
,\x41
,0101
(az utóbbi oktális, melyet a kezdő 0 jelez). A legfontosabb speciális karakterkonstansok:- '\n': új sor (LF)
- '\r': kocsi vissza (CR)
- '\t': tabulátor
- '\b': backspace
- '\a': alarm (sípolás)
- '\\': backslash
- short (vagy short int): rövid egész.
- int: az egész konstans formája azonos char-ral, csak az érték lehet nagyobb. Több karakter megadása aposztrófok között nem szabványos, bár néhány fordító megengedi.
- long (vagy long int) konstans pl.:
65L
. - long long (vagy long long int) konstans pl.:
65LL
. - float, double, long double konstans pl.:
3.14
,8.3e11
,8.3d-11
. Float típusú konstans3.14F
, long double3.14L
alakban adható meg. Ha nincs típusjelzés, a konstans double típusú. - void: speciális adattípus, mellyel semmilyen művelet nem végezhető, még értékadás és konverzió sem. Mutatók és függvények esetén használatos.
A char, short, int, long és long long fixpontos, a float, double és long double lebegőpontos típus. Fixpontos adattípuson nincs túlcsordulás-ellenőrzés: az hibás működést eredményez.
A C-ben nincsen string típus (bár string konstans van, a példaprogramban: "Haho\n"). A stringet karaktertömbben tartja, a string végét bináris nulla ('\0'
) jelzi.
A C-ben nincs logikai típus (igaz vagy hamis). A nem 0 értékű fixpontos kifejezés a logikai igaz, a 0 értékű a hamis.[5] A relációk (melyek szintén aritmetikai műveletek) igaz értékként 1-et adnak vissza.
A char
típusú változóval ugyanazok a műveletek elvégezhetők, mint az int
-tel. Ilyenkor a karakter egésszé konvertálódik.
A char, int, long és long long típus előtt használható a signed
ill. unsigned
típusmódosító. A nyelv nem definiálja, hogy a char
típus egész számként használva előjeles-e, ezért ha az érték 127-nél nagyobb, mindenképpen meg kell adni, hogy hordozható legyen a kód. Az int, long és long long előjeles, ha az unsigned
-et nem adjuk meg.
Az előjeltelen konstansot az utána írt U
jelzi, pl. 15U, 15UL, 15ULL. A hexadecimális alakú konstans (0xF) előjeltelen (az utána írt S
betűvel tehető előjelessé), a többi alak előjeles, ha nincs utána U.
A C nyelv az alábbi típusokkal tud műveletet végezni:
- int
- unsigned int
- signed long
- unsigned long
- signed long long
- unsigned long long
- double
- long double.
Minden más típus csak tárolásra való, aritmetikai műveletben azonnal átkonvertálódik a nála nagyobb, előjelben megfelelő típusra.
Deklarációk
A deklaráció a fordítóprogramnak szóló utasítás. Kódot nem generál, a fordítóprogram szimbólumtáblájában okoz változást.
A C-ben háromféle deklaráció van:
Használat előtt a változókat és típusokat deklarálni kell. A függvényeket nem kötelező, de nyomatékosan ajánlott.
Változó deklarálása
A deklaráció hatására foglalja le a fordítóprogram a memóriaterületet a változó számára, és megadja a memóriaterület nevét, amivel hivatkozni lehet a tartalmára.
Négy dolgot lehet/kell megadni a változó nevén felül:
- az adat láthatóságát a program különböző részeiből
- a tárolási osztályt
- az adat típusát
- a kezdőértéket.
A C-ben – meglehetősen szerencsétlen módon – az első kettőt nagyjából ugyanazokkal a kulcsszavakkal kell megadni.
Láthatóság
Az adat láthatósága C-ben háromféle lehet:
- globális (az egész programból látható)
- csak a forrásfájlból látható
- csak a blokkon belül látható.
A blokkon belül deklarált változók csak a blokkon belül láthatók (beleértve a blokk által tartalmazott blokkokat is). Ha a blokk egy külső blokkbeli vagy blokkon kívüli változónevet használ, akkor saját példányt definiál belőle, és (névvel) nem tudja elérni a feljebb levő azonos nevű változót.
C-ben függvényen belül nem lehet függvényt definiálni, ezért a függvényen (blokkon) kívüli adatok mindig statikusak, azaz a program indulásától kezdve ugyanazon a memóriaterületen vannak, így ezt a tényt nem kell külön megadni. A blokkon kívüli static
kulcsszó az adat vagy függvény láthatóságát a forrásfájlon belülre korlátozza. A blokkon kívül deklarált, static
nélküli változó és a static
nélküli függvény globális.
Globális változóra vagy függvényre a program többi forrásfájljából az extern
kulcsszóval hivatkozhatunk, melyben meg kell adni a változó nevét, típusát és a tárolási osztályt. Hogy ne kelljen mindezt többször leírni, általában saját header-fájlokat használunk, melyeket minden forrásfájl betölt a #include
preprocesszor-utasítással. extern
változónak nem lehet kezdőértéke. A program valamelyik forrásfájljában (általában a főprogramban) a változót extern
nélkül kell deklarálni, és itt kaphat kezdőértéket.
Tárolási osztály
Betöltéskor létrejövő adatok |
Verem | Változó memóriatartalom |
Kezdőértéket nem kapott adatok | ||
Programfájlban tárolt adatok |
Kezdőértéket kapott adatok | |
Konstansok | Konstans memóriatartalom | |
Programkód |
A tárolási osztály adja meg, hogy az adat a program melyik memóriaterületére kerül (lásd jobb oldali táblázat, középső oszlop).
A blokkon (függvényen) kívül deklarált adat mindig statikus, a blokkon belüli – ha mást nem adunk meg – dinamikus. Blokkon belüli adat a static
kulcsszóval tehető statikussá, és az extern
jelzi, hogy másik forrásprogramban van deklarálva. Az extern
kulcsszót blokkon kívül szokás használni, és mindig statikus adatra vonatkozik.
A statikus adatnak állandó helye (memóriacíme) van. A dinamikus adat a veremben tárolódik, a blokkba belépéskor foglalódik le a helye, kilépéskor felszabadul, kezdőértéke definiálatlan.
A register
kulcsszóval javasolhatjuk a fordítóprogramnak, hogy a dinamikus adatot ne veremben, hanem a CPU regiszterében tartsa. Az ilyen változóknak nincs memóriacímük, így a &
művelet nem használható rájuk. Kezdőértékük definiálatlan. Ha nincs elég regiszter, akkor a deklaráció ellenére verembe kerül az adat. A jelenlegi igen jól optimalizáló fordítók mellett a register
használata idejétmúlt.
A programban kezdőértéket nem kapott statikus adatok 0 értéket kapnak, amikor az operációs rendszer a memóriába tölti a programot.
Konstans változót a const
kulcsszóval lehet megadni, és kötelezően kezdőértéket kell kapjon, mely a program végrehajtása során nem változik, és a fordítóprogram ellenőrzi is, hogy ne szerepelhessen olyan utasításban, ahol értéket kaphatna. A konstans memóriaterületre kerülnek azok a konstansok is, melyeknek nincs nevük ("Haho\n"
a mintapéldában).
A változó típusa
Háromféle lehet:
Kezdőérték
Kezdőérték a változónév utáni =
jelet követő konstanssal adható meg. Kezdőérték adható dinamikus változónak is, de az érték beállításához a fordítóprogram kódot generál, és nem teszi a kezdőértékeket a konstansok memóriaterületére.[6]
Tömbök és összetett változók kezdőértékeit {
és }
közé kell tenni, a zárójelbeli értékeket vesszővel elválasztva. Nem hiba az utolsó érték után is kitenni a vesszőt.
Ha egy változónak nincs kezdőértéke, akkor az dinamikus változó esetén definiálatlan, statikus változó esetén 0 (lásd: tárolási osztály).
Példák változódeklarációra
int i;
int a, b=2;
static const unsigned short alfa = 88;
extern int globalis;
Struktúra
A struktúra különböző típusú adatokból álló adat. A struktúra szerkezetét és a változókat lehet együtt vagy külön-külön deklarálni. Az alábbi két példa egyenértékű:
struct datstr {
short ev;
short ho;
short nap;
};
struct datstr ma, holnap;
|
struct {
short ev;
short ho;
short nap;
} ma, holnap;
|
Az első példában az első utasítás az adatszerkezetet definiálja (melyet gyakran header-fájlba teszünk, ha több forrásfáljból is használni akarjuk), a második deklarálja a változókat.
A második esetben a struktúrának nem kell kell neve legyen, bár ilyenkor nem használhatjuk a definiált adatszerkezetet később, más változó deklarálásához.
Kezdőértékadás a deklarációban:
struct datstr ma = { 2015, 12, 4 };
Értékadás aritmetikai utasítással:
holnap = ma;
holnap.nap = 5;
A struktúrák egymásba ágyazása:
struct {
struct datstr dat;
short ora;
} pelda;
Az évre pelda.dat.ev
néven hivatkozhatunk, pelda.ev
néven nem.
Mutatóval adott struktúra tagjaira a ->
művelettel lehet hivatkozni.
Unió
Az unió (union
) formailag megegyezik a struktúrával, de a tagjai (melyek rendszerint struktúrák) azonos memóriaterületen helyezkednek el. Az unió mérete a legnagyobb tag mérete lesz. Arra szolgál, hogy ugyanazt a memóriaterületet a program különböző időpontokban különböző célokra használhassa. Rendszerprogramokban fordul elő, felhasználói programban ritka.
enum
Akkor használatos, ha egy egész változó csak néhány értéket vehet fel, és ezekre az értékekre (tipikusan kódokra) névvel akarunk hivatkozni a könnyebb megjegyezhetőség érdekében. Alakja a struktúrához hasonló, pl.:
enum httpkod { VAN=200, TILTOTT=403, NINCS=404 } htkod;
httpkod
a struktúranév megfelelője, htkod
a változó neve. A struktúrához hasonlóan külön is megadható a kettő. A kapcsos zárójelben nem kötelező értékeket megadni, ilyenkor a fordítóprogram 0-tól egyesével növekvő értékeket rendel a felsorolt nevekhez.
C-ben az enum – a C++-tól eltérően – nem definiál külön adattípust, egyszerűen hozzárendeli a felsorolt nevekhez az egész értékeket. A nevek ezután bármilyen aritmetikai kifejezésben szerepelhetnek, mintha egész típusú konstansok lennének, de a program hordozhatósága érdekében ezt a tulajdonságot nem ajánlatos kihasználni.
Tömbökszerkesztés
A programozásban tömbnek olyan változókat neveznek, melyek több azonos típusú adatból állnak. A deklaráció formája azonos a skalár (nem tömb) típusú változóval. Az elemek számát C-ben a változónév után szögletes zárójelben kell megadni (csak egész típusú érték lehet), a kezdőértékeket pedig a struktúráknál megismert módon. Pl:
int egesztomb4;
const int allando3 = { 1, 2, 3 };
Információ forrás: https://hu.wikipedia.org/wiki/C_(programozási_nyelv)
A lap szövege Creative Commons Nevezd meg! – Így add tovább! 3.0 licenc alatt van; egyes esetekben más módon is felhasználható. Részletekért lásd a felhasználási feltételeket.
Analóg multiméterek túlterhelés elleni védelme
Egyenáram
Egyenáram mérése
Egyenirányítós lengőtekercses műszer
Elektromágnes (fizika)
Elektromos feszültség
Elektromos térerősség
Fáziseltolódás
Fázismutató
Fajlagos ellenállás
Feszültséggenerátor
Feszültségváltó
Forgó mágneses tér
Háromfázisú hálózat
Hőelektromosság
Hatásos ellenállás
A lap szövege Creative Commons Nevezd meg! – Így add tovább! 3.0 licenc alatt van; egyes esetekben más módon is felhasználható. Részletekért lásd a felhasználási feltételeket.