2015. május 6., szerda

C program felépítése

Jellemző felépítés

Egy C program jellemző felépítése az alábbi:
#include sorok
a saját #define sorok
a közös változók, típusok deklarálása
a saját függvények deklarálása és definiálása (törzsének megadása)
a main() függvény
Példaprogram
Példaprogram

Példaprogram magyarázata

Az alábbiakban egy egyszerű C programot adunk meg:
#include <stdio.h>#include <conio.h>
void main(){
printf(”Hello Vilag!\n”);
printf(”<nyomj [ENTER]-t>\n”);
getch();}
A printf könyvtári függvény deklarációja az stdio.h file-ban van leírva. Hogy ne kelljen onnan bemásolnunk ezt a sort, az egész .h file-t beemeljük az #include segítségével.
A getch függvény deklarációja a conio.h file-ban van leírva, ezért ezt is beemeljük.
A programban kötelező szerepelnie egy main() függvénynek, mely a program kezdőpontja egyben. Ennek típusa vagy int, vagy void. Most a void-ot választottuk, így nem kell visszatérési értéknek lennie.
A printf függvény képernyőre írja a megadott szöveget. Egy printf egy sort ír ki, ha a kiírandó karakterek között szerepel a \n vezérlő karakter, mely a soremelést jelöli.
A getch() függvény megvárja egy tetszőleges billentyű leütését. Elvileg a leütött billentyű kódját meg is adná, de ezzel nem törődünk. Jelen esetben csak arra használjuk, hogy várakozzunk egy tetszőleges billentyű lütésére.
 

A C nyelv alapelemek

Eszköztár:

Lexikai elemzés
A számítógépes program szövege közönséges text file, melyben karakterek sorozata írja le a program utasításait.

 A program szövegét a fordítóprogram dolgozza fel.

 Az első lépés az alapelemek generálása, vagyis a lexikai elemzés. Például, egy számológép program inputjaként (bemenő adat) a következő karaktersorozat érkezik be: "12*(3+4)^2". A lexikai elemző a bemenetből a következő alapelemeket generálja: 12; *; (; 3; +; 4; ); ^ és 2. Ezek azok az alapelemek, amelyek az aritmetikai kifejezések körében konkrét jelentéssel bírnak. Az elemző tartalmaz olyan szabályokat, amelyek mutatják, hogy például a *, +, ^, (and) karakterek egy új alapelem kezdetét jelzik, ezért nincsen értelme az olyan alapelemek létrehozásának, mint például "12*" vagy "(3".
Jelkészlet
A jelkészlet határozza meg, hogy a feldolgozás közben milyen karaktereket ért meg a fordítóprogram, vagyis milyen karakterek segítségével írhatjuk le a program szövegét.

 Jellemző, hogy a karakterkészlet az ASCII kódtáblából kerül csak ki. Ugyanakkor a mai fordítóprogramok már az egyszerűsített UNICODE kódtábla alapján is képesek a program szövegét karakterekre bontani.

 A C nyelv jelkészlete az angol ABC kis-, és nagybetűin, a számjegyeken kívül az alábbi karakterekből áll:

 ! " # % & ' ( ) * + , - / : ; < = > ? [ \ ] ^ _ { | ~
White-space karakterek
A program szövegét ún. white-space karakterek tördelik szét. Ilyennek számít maga a szóköz, a tabulátor, és a sorvége jel (Enter).

 A programozási nyelvek szintaktikája általában úgy fogalmaz, hogy ahol állhat egy white-space karakter, ott állhat több is.
Szimbólumok
A szimbólumok a lexikai elemzés alapelemei. Egy vagy többkarakteres szimbólumokat használunk a program írása során.
Egykarakteres szimbólumnak számít a ’+’ jel, mely lehet az összeadás szimbóluma. Többkarakteres szimbólumnak számít a ’!=’ (nem egyenlő), az összehasonlítás jele.
A lexikai elemzőnek fel kell tudni ismerni a többkarakteres szimbólumokat, és azokat egyetlen szimbólumként kínálni fel a szintaktikai elemző felé.
Azonosítók
A program írása során a saját programozási elemeinknek nevet, azonosítót adunk. Később a program szövegében ezen azonosítóval hivatkozhatunk a megfelelő programozási elemre.
Ilyen programozási elem lehet:
  • saját típus
  • változó
  • függvény
  • konstans
  • címke
  • stb.
Mindig nagyon izgalmas kérdés, hogy egy adott programozási nyelven milyen maximális hosszúságú azonosítókat lehet használni, illetve a kis-, és nagybetűk különbözőnek számítanak-e.
A C nyelvben az azonosítók hossza nincs korlátozva, de néhány fordító mégis 32 karakterig hajlandó azokat csak feldogozni.
A C nyelv minden fordítója különböző karaktereknek tekinti a kis-, és nagybetűket (case-sensitive nyelv).
Címkék
A címke a program szövegén belül valamely utasítást azonosít. Leggyakrabban akkor használunk címkéket, amikor ugró utasítást programozunk. Ekkor címkével azonosítjuk azt a pontot a program szövegén belül, ahova a vezérlést át kívánjuk helyezni (ugrani akarunk).
Megjegyzések
A megjegyzések a forráskódban a fordítóprogram szempontjából érdektelen részek, melyeket figyelmen kívül hagy.
Ugyanakkor a megjegyzések segítségével a programozó saját magának tud az adott kódrészben üzeneteket, figyelmeztetéseket elhelyezni. Ezek igen hasznosak, ha az adott programkódot később újra meg kell érteni, esetleg módosítani szükséges.
Literálok
A literálok a programkódban található direkt formában beírt adatok. Ilyen literálok például a 12, a -24.5, vagy az ”alma” szöveg.
A literálok hasonlítanak a konstans fogalmára, de a konstansoknak nevük is van, a literáloknak pedig nincs.
A literáloknak mindig van típusuk, amelyet a fordítóprogram a literál alakjából automatikusan (implicit módon) határoz meg.
A karakter literálok például a C-ben mindig aposztrófok között szerepelnek, pl. ’a’.
A string literálok idézőjelek közé vannak zárva, pl. ”alma”.
Az egész szám literálok tízes számrendszerbeli számok, pl. -423.
A lebegőpontos (tört) számokban tizedespont szerepel, pl. 3.1415.
Foglalt szavak
A foglalt szavak olyan kulcsszavak, melyeknek a fordítóprogram tulajdonít jelentést, és emiatt saját elemeink azonosítására nem használhatók fel, jelentésük nem bírálható felül.
A C nyelvben foglalt szó például a do, while, if, int, static, enum, new, for stb. szavak.


C nyelvi azonosítók


Eszköztár:




Deklaráció

A programozás során új programozási elemeket (típusok, változók, konstansok, függvények, stb.) vezetünk be a program szövegben. Ezen elemeknek nevet (azonosítót) kell adni, és a fordítóprogram számára világosan megadni, hogy ezen azonosító milyen új programozási elemet is takar. Ezt a folyamatot nevezzük deklarációnak.

Case-sensitivity

A C nyelv, és minden rokona kisbetű-nagybetű érzékeny az azonosítókkal kapcsolatosan. Így a ’Pi’ és a ’pi’ azonosítók különbözőek. Ez vonatkozik minden, a program szövegében definiált azonosítóra, legyen az típus, konstans, változó, függvényazonosító.
A C nyelv azonosító névképzési szabálya
A C nyelv azonosítóinak névképzési szabályai:
Az azonosítók neve betűvel vagy aláhúzással kezdődhet.
A további karakterek betűk, számjegyek, vagy az aláhúzás jel lehet.
Az azonosítók neve tetszőleges hosszú lehet.
Az azonosítók névképzése során a ’betű’ elvileg csak az ANGOL ABC kis-, és nagybetűit tartalmazza.
A C nyelv, és minden rokona kisbetű-nagybetű érzékeny az azonosítókkal kapcsolatosan. Így a ’Pi’ és a ’pi’ azonosítók különbözőek.
Azonosító névképzési szabálya
A névképzési szabályok írják le, hogy amennyiben új azonosítót (változónév, konstansnév, függvénynév, stb.) kívánunk a programban bevezetni, úgy hogyan kell annak a névnek 'kinéznie’.
Definíció
Több olyan nyelvi elem is van, amelyik nem csak deklarációt igényel, hanem definíciót is:
  • a változók deklarációja fontos, de a változóknak helyet is kell biztosítani a memóriában
  • a függvények deklarációja fontos, de a függvény törzsének megadása nélkül használhatatlan
Hagyományok a névképzésben
Hagyományok a C nyelvi azonosítók névképzési szabályaiban:
  • Ne kezdjünk aláhúzás jellel (általában a rendszer által használt azonosítók kezdődnek aláhúzás jellel)!
  • Kis-, és nagybetűk különbözőek!
  • Kisbetűvel írjuk a C++ azonosítókat
  • Csupa nagybetűvel az előfordító által használt neveket (makrókat).
Explicit deklaráció
Az explicit deklaráció során az új nyelvi elemről minden információt a program szövegébe is beírunk. Annak ’elolvasása’ révén a fordítóprogram megérti az új nyelvi elem szerepét.
Az implicit deklaráció során a fordítóprogramnak kell bizonyos, a program szövegébe direktben nem beleírt információkat kikövetkeztetni.
Ez utóbbira jellemző példa a literálok használata. Egy egész szám literál, pl. ’12’ esetén nincs melléírva, hogy ez egy int típusú érték, de a fordítóprogram a literál alakjából képes ezt önállóan is meghatározni.
  


Típusok


Eszköztár:



A típus definíciója
A típus (adattípus) azonosítja
  • az adott típuson tárolható adatok milyenségét (halmazát)
  • a tároláshoz szükséges memória mennyiségét (B-ok darabszáma)
  • a tároláshoz felhasznált memóriaterület részeinek jelentését (akár a bit-ek szintjéig)
  • az ilyen típusú adatokon végezhető műveleteket (pl. összeadás, összehasonlítás, stb.)
Signed és unsigned
Amennyiben egy egész szám típus csak pozitív számok tárolását engedi meg (unsigned), akkor az adott bitmennyiségen (jelöljük ezt n-el) 0…2^n-1 nagyságú számokat lehet tárolni.
Pl: 8 biten 0…2^8-1, vagyis 0..255 közötti értékeket lehet ábrázolni.
Amennyiben egy egész szám típus megengedi a negatív számok tárolását is (signed), akkor az adott bitmennyiségen nagyságrendileg csak feleakkora számok tárolhatók.
Pl. 8 biten csak 255/2 vagyis körülbelül 128-ig tárolhatunk egész számokat, igaz, ez a negatív irányban is megvan.
Pontosabban: 8 biten -128 .. +127 közötti számokat lehet ábrázolni.
Tárolási méret
Egy típus tárolási mérete azt határozza meg, hogy a memóriában egy ilyen típusú érték hány B-ot foglal le.
Egész számok esetén minél nagyobb a tárolási méret, annál nagyobb számokat tudunk leírni.
Valós számok esetén minél nagyobb a tárolási méret, annál nagyobb számokat tudunk leírni, de annál pontosabban is, hiszen itt a számjegyek száma is fontos!
Egész számok esetében lehetőség van két tárolási módosítót használni:
  • short :rövid
  • long: hosszú
Char
A char típus az egész számok egy speciális altípusa. Az ’unsigned char’ típus képes egy 0..255 közötti egész érték leírására. Ez (nem véletlenül) egyben az ASCII kódtáblában előforduló kódok leírására éppen elég.
Ennek megfelelően a char típusú változóban lévő érték (nézőpont kérdése)
  • lehet egy 0 .. 255 közötti egész számnak is felfogni
  • vagy lehet egy karakterkódnak, amely egy karaktert azonosít
Egész típus
Az egész típus egy típuscsalád, melynek sok tagja van. Ezen tagok mindegyike egész számok tárolására alkalmas, de különböznek egymástól tárolási méretben, és mindegyiknek van signed és unsigned változata is:
  • char 1B
  • short int 2B
  • int 4B
Ez a táblázat csak akkor igaz teljes mértékben, ha a C fordítónk 32 bites.
char (signed) -128..127 1 byte
unsigned char 0..255 1 byte
short int (signed) -32768..32767 2 byte
unsigned short int 0..65535 2 byte
int (signed, long) -2147483648..2147483647 4 byte
unsigned int (long) 0..4294967295 4 byte
Lebegőpontos típus
A valós számok típuscsalád elsősorban tört számok tárolására képes, de természetesen képes egész számok tárolására is.
A típusok között különbség a memóriaigényük. Minél több memóriát köt le egy típus, annál nagyobb pontossággal (több számjegy) képes tárolni az adott tört számot, illetve annál nagyobb számok tárolására képes.
A ’float’ típus 7 számjegy pontossággal tárol (ebbe az egész számjegyek is benne vannak).
A ’double’ típus (ezt használjuk gyakrabban) viszont 15 számjegy pontossággal tárolja a számokat. Használata során 8B helyigény jelentkezik.
Logikai típus
A logikai típus a C nyelvből hiányzik. Helyette a char típust szokták használni, melynek tárolási igénye szintén 1B.
A logikai hamis értéket a 0 érték képviseli, minden más érték a logikai igaz értéknek tekintendő.


Literálok


Eszköztár:






Egész literálok

A literálok név és típusjelzés nélküli adatok, melyek a program szövegében szerepelnek.
A literálok típusa nincs a literál mellett feltüntetve, de a fordítóprogram képes annak meghatározására a literál alakjából (implicit típusmeghatározás).
Az egész szám literálokat általában tízes számrendszerbeli alakjukban írjuk be. Pl.: 1432, vagy -123.
Az egész szám literálok típusa (függetlenül azok értékétől) mindig ’int’.
Lehetőség van tizenhatos számrendszerben is beírni az egész szám literált. Ekkor a ’0x’ előtaggal kell kezdeni. Pl.:: 0x14 literál típusa int, értéke egyébként 20.

Egész típus-módosítók

Egész szám literálok (amennyiben nem kérünk eltérő ábrázolási módot) mindig ’int’ típusúak.
Ezt a literál után írt karakterjelzéssel tudjuk módosítani:
  • u,U: unsigend tárolás kérése
  • l,L: long tárolás kérése
Vagyis míg a 12432 literál int típusú, addig a 12432u vagy 12432U típusa unsigned int lesz.

Karakter literálok

A karakter típusú literálok mindig aposztrófok között szerepelnek. Pl. ’a’, vagy ’?’.
Azon karakterek, melyek nem szerepelnek a billentyűzeten, beírhatóak az ASCII kódtábla szerinti 16-os számrendszerbeli kódjukkal. Ezeket a ’\x’ előtaggal kell kezdeni (pl. ’\x1F’ jelöli a 31-es kódú karaktert).
A sűrűn használt speciális karaktereknek speciális beírási jelölésük van. A ’\n’ a 10-es, ’\r’ a 13-as, a ’\a’ a 7-es kódú ASCII kódú karaktert jelöli.
Magát az aposztróf karaktert szintén speciális kell beírni: ’ \’ ’. Hasonlóan, az idézőjelet a ’ \” ’ módon.
A perjel is speciálisnak minősül, mivel a fenti esetekben speciális jelentése van. Így magát a perjelet ’\\’ jelöli.

Escape szevenciák

Az alábbiakban megadjuk, melyik speciális karakternek mi a rövidített írásmódja (perjeles mód):
kocsi-vissza 13 '\r'Újsor 10 '\n'
aposztróf ' '\''idézőjel " '\"'
backslash \ '\\'csengő 07 '\a'
visszatörlés 08 '\b'lapdobás 12 '\f'
vízszintes tabulálás 09 '\t'függőleges tabulálás 11 '\v'

Lebegőpontos literálok

A valós szám típusú literálok ismertetőjele, hogy tizedespontot tartalmaznak. Pl.: a 12.456 vagy a -3.14 valós szám literálok.
A valós szám literálok típusa minden esetben ’double’.
Lehetőség van normál alakban is beírni valós számot. Pl. a 0.12345E+02 is egy double típusú valós szám literál, értéke egyébként 12.345.

Lebegőpontos típus-módosítók

A valós szám típusú literálok (amennyiben nem kérünk eltérő ábrázolási módot) mindig ’double’ típusúak.
Ezt a literál után írt karakterjelzéssel tudjuk módosítani:
  • f,F: float típus kérése
  • ó
  • d,D: double típus kérése
Vagyis míg a 124.32 literál double típusú, addig a 124.32f vagy 124.32F típusa float lesz.
A d,D módosító használatára ritkán kerül sor, mivel a valós számok eleve double típusúak. Ugyanakkor pl. a 12 literál int lenne, a 12d pedig double lesz. Hasonló eredményt érünk el, ha 12.0 formában írjuk fel a literált.

Szöveg literálok

A string típusú literálok minden esetben idézőjelek között szerepelnek, pl. ”alma”.
Amennyiben a string literálok belsejében speciális karaktert kell írni, úgy a karakter literáloknál megadott szabályok szerint kell azt megtenni. Pl. ”alma\nfa” egy 7 karakter hosszú string literál, melynek ötödik karaktere a speciális 10-es kódú karakter.
Filenév esetén ügyelni kell, a ’\’ speciális karakternek számít, speciálisan kell beírni: pl. ”c:\\almafa.txt” a helyes, ha csak egy ’\’-et használnánk, akkor hibát eredményezne

 

Konstansok

Eszköztár:




Egész típusú konstansok

A C nyelven nincs lehetőség konstansok létrehozására.
A konstansokat ügyes trükkel szokták megvalósítani. Kihasználják az előfordító szerepét, és a #define direktíva segítségével hozzák létre a konstansokat.
Hagyományból, a #define után álló azonosítók nevét csupa nagybetűvel írjuk.
Pl.:
#define ELETKOR 45
#define ELEMSZAM 20
Megjegyeznénk, hogy ez nem konstans, mivel explicit típus-meghatározása sincs, és a #define utáni név nem tekinthető azonosítónak sem.
Ugyanakkor a literálok (45, 20) egész típusú literálok, ezért az „ELETKOR” és „ELEMSZAM” literálok a program szövegében ezen egész szám értékeket szimbolizálják, ezért egész szám konstansoknak is tekinthetőek.

Karakter konstansok

A C nyelven nincs lehetőség konstansok létrehozására. Amennyiben mégis karakter típusú konstansokra van szükségünk – úgy egy trükkel lehet azt elérni:
Pl.:
#define SOREMELES ’\r’
#define KOCSIVISSZA ’\n’
Megjegyeznénk, hogy ez nem konstans, mivel explicit típus-meghatározása sincs, és a #define utáni név nem tekinthető azonosítónak sem.
Ugyanakkor a literálok (’\r’, ’\n’) karakter típusú literálok, ezért a „SOREMELES” és „KOCSIVISSZA” literálok a program szövegében ezen karakterek értékeit szimbolizálják, ezért karakter konstansoknak is tekinhetőek.

Lebegőpontos konstansok

A C nyelven nincs lehetőség konstansok létrehozására. Amennyiben mégis valós típusú konstansokra van szükségünk – úgy egy trükkel lehet azt elérni:
Pl.:
#define PI 3.1415
Megjegyeznénk, hogy ez nem konstans, mivel explicit típus-meghatározása sincs, és a #define utáni név nem tekinthető azonosítónak sem.
Ugyanakkor a literál (3.14) double típusú literál, ezért a PI literál a program szövegében ezen valós értékeket szimbolizálja, ezért valós típusú konstansnak is tekinthető.

Szöveg konstansok

A C nyelven nincs lehetőség konstansok létrehozására. Amennyiben mégis szöveg típusú konstansokra van szükségünk – úgy egy trükkel lehet azt elérni:
Pl.:
define CEGNEV ”Dream Team Software House”
Megjegyeznénk, hogy ez nem konstans, mivel explicit típus-meghatározása sincs, és a #define utáni név nem tekinthető azonosítónak sem. Szintén érdekes észrevétel, hogy nincs string típus sem a C nyelven.
Ugyanakkor a literál (”....”) string típusú literál, ezért a „CEGNEV” literál a program szövegében ezen szöveg értékeket szimbolizálja, ezért szöveg típusú konstansnak is tekinthető.

Logikai konstansok

A C nyelven nincs lehetőség konstansok létrehozására. Amennyiben mégis logikai típusú konstansokra van szükségünk – úgy egy trükkel lehet azt elérni:
Pl.:
#define TRUE 1#define FALSE 0
Megjegyeznénk, hogy ez nem konstans, mivel explicit típus-meghatározása sincs, és a #define utáni név nem tekinthető azonosítónak sem.
Mivel C-ben nincs logikai típus, ezért az egész típust szoktuk erre a célra felhasználni. A program szövegében a TRUE és FALSE literálok a fenti 1 és 0 értéket fogják képviselni, és felfoghatóak logikai konstansoknak is.
Mi az a konstans
A konstansok a programban névvel, típussal, értékkel ellátott adatok. Az azonosító a program futása során végig ugyanezen értéket kell, hogy jelentse (nem megváltoztatható érték).



Operátorok

Eszköztár:

Operátorok
Az operátorok a kifejezések építésében játszanak szerepet.
Az operátorokat csoportosíthatjuk operandusaik száma szerint:
  • egyoperandusú (unáris), pl. a negatív előjel, vagy a logikai tagadás
  • kétoprandusú (bináris), pl. az összeadás
  • háromoperandusú, egyetlen ilyen van: a „?:” operátor
Az egyoperandusú operátor az operandusa előtt szerepel, pl. ’char b = !a;’
A kétoperandusú operátorok minden esetben infix operátorok, vagyis a két operandus között állnak. Pl. ’int a = b+c;’.
Operátorokat csoportosíthatjuk a szerint is, hogy jellemzően milyen típusokon értelmezettek:
Logikai operátorok: tagadás, és, vagy.
Numerikus operátorok: összeadás, kivonás, stb.
Összehasonlító operátorok: kisebb, kisebb egyenlő, nem egyenlő, stb.
Szöveg operátorok: összefűzés.
Aritmetikai operátorok
Aritmetikai operátorok:
  • kétoperandusú kivonás
  • egyoperandusú negatív szám képzése
+ kétoperandusú összeadás
* kétoperandusú szorzás
/ kétoperandusú osztás
% kétoperandusú modulus képzés ( pl: 5%2 = 1 )
Relációs operátorok
Az összehasonlító operátorok (<, <=, >, >=, ==, !=) többféle adattípuson (egészek, valósak, karakter, logikai) működnek.
Az összehasonlító operátorok minden esetben logikai (igaz v hamis) értéket állítanak elő.
Egész számokon és valós számokon az összehasonlító operátorok működése értelemszerű.
Karakter típus esetén a karakter számkódja adja az összehasonlítás alapját. Ennek megfelelően pl. a kis ’a’ betű (amelynek kódja 97) nagyobb, mint a nagy ’A’ betű, melynek kódja 65). De hasonlóan kell értelmezni azt a kérdést is, hogy a ’&’<’7’.
Bitszintű operátorok
Bitszintű operátorok:
& bitenkénti ÉS
| bitenkénti VAGY
^ bitenkénti KIZÁRÓ VAGY
~ bitenkénti NEGÁCIÓ (komplementer)
>> bitenkénti jobbra léptetés
<< bitenkénti balra léptetés
Értékadó operátor
Az értékadás jele ( = ) is operátornak tekintendő a C nyelvben. Az értékadás operátora az előállított értéknek azt tekinti, amely értéket az értékadás során a változóba elhelyez.
int a,b,c,d;
a=12;
b=c=a+1;
esetén az ’a+1’ fog először kiértékelődni, majd ezen érték (13) beíródik a ’c’ változóba. Ezen értékadás operátor ezt a 13 értéket tekinti végeredménynek, s ezt írja be a ’b’ változóba.
A zárójelezés segíthet a működés megértésében:
b= (c= (a+1) );
Növelés és csökkentés
A növelés és csökkentés operátorai:
-- egyoperandusú dekrementálás
++ egyoperandusú inkrementálás
Egyoperandusú operátorok szerepelhetnek az operandus előtt és mögött is. Ezekben az esetekben eltérő működés jellemzi őket:
int a = 12;
Az ’a++; ’ jelentése: növeld meg az ’a’ értékét 1-el. Ugyanazt jelenti a ’++a’ is. Az eltérés akkor van, ha ezt egy kifejezésben szerepeltetjük:
int b = a++;
Ebben az esetben ’b’ értéke 12 lesz, és az ’a’ értéke 13. Ugyanis az ’a’ mögé írt növelés operátora először meghatározza saját végeredményét (’a’ értéke), majd csak utána növeli meg az ’a’ értékét 1-el.
int b = ++a;
Ebben az esetben ’b’ értéke 13 lesz, és az ’a’ értéke 13. Ugyanis az ’a’ elé írt növelés operátora előbb hajtja végre a növelést, majd határozza meg saját végeredményét.

Nézzünk egy példát:
Írjunk programot, amely meghatározza az első természetes szám összegét!
1. Nézzük először azt a megoldást, amely egy ciklust használ az összeg meghatározására. 

#include <stdio.h>

main()
{
  unsigned n, osszeg = 0, i;
  printf( "N = " );  scanf( "%u", &n );
  for ( i = 1; i <= n; osszeg += i++ )
    ;
  printf( "Az első %u természetes szám összege: %u\n", n, osszeg );
}


  A feladatot meg lehet oldani egyszerűbben is, ha ismerjük az első természetes szám összegének zárt képletét. Talán mondanunk sem kell, ez gyorsabb program, mint az előző. 

#include <stdio.h>

main()
{
  unsigned n;
  printf( "N = " );  scanf( "%u", &n );
  printf( "Az első %u természetes szám összege: %u\n",
          n, n * ( n + 1 ) / 2 );
}

 

 Példatár:
http://www.inf.unideb.hu/kmitt/konvkmitt/c_peldatar/book.xml.html


Bejegyezte: dátum:

Nincsenek megjegyzések:

Megjegyzés küldése

Feliratkozás: Megjegyzések küldése (Atom)