ТиповеC е функционален език, тоест език базиран на функции. Грубо казано програмите на него вървят, като последователно се извикват въведени от програмиста функции. Функиите приемат аргументи, които може да са променливи или константи и връщат стойности. Константите, променливите и върнатите стойности имат
тип, който може да е сред няколко основни типа. Това са int, short, long, char, float, double.
int (идва от integer / цяло число)
Типът
int се използва за цели числа. В по-новите компилатори неговата големина е 4B (байта) или 32bit (бита). Това означава че може да приема 2^32 или 4294967296 различни стойности. По подразбиране int има знак (+ или -) и съответно може да приема стойности от -2147483648 до +2147483647 (защо не до +2147483648 ще ми кажете вие

).
Върху променливи от тип int могат да се използват следните аритметични операции: +, -, *, /, %. При +, - и * няма нищо странно, извършват се както очаквате. / в случая се нарича целочислено делене. Когато разделим две променливи от тип int
a и
b резултатът е цялата част на a/b, например
5/2 = 2.5,
8/3 = 2.(6). % се нарича
сравняване по модул или остатък при деление. Тоест 11/3 = 3(2) (3 и остатък 2, защото 3*3 + 2 = 11) => 11%3 = 2 (остатъка).
short (идва от short (да не повярва човек), което значи къс)
short също е целочислен тип. С тази разлика че паметта която заема е 2B или 16bit. Тоест може да приема 65536 различни стойности, и ако има знак това значи от -32768 до +32767. Аритеметичните операции, които могат да се прилагат са същите, като при int.
long (идва от long/ дълъг)
long е третият целочислен тип в C, макар че заедно с short могат да се смятат за разновидности на int. Има големина 4B и е напълно идентичен с int. Смъсъла от него е, че ако не сте сигурни дали компилатора ви е 16 битов или 32 битов (т.е. дали подразбиращата се големина на int е 2B или 4B) така се подсигурявате

.
char (идва от character / писмен знак)
char е по-интересен тип. Големината му е само 1B или 8bit което значи че може да приема само 256 стойности, и ако има знак това са целочислените стойности от -128 до +127. На всяка стойност обаче отговаря определен знак, според известната
ASCII таблица (тя е 7 битова, което значи че имаме още 128 стойности който липсват в нея. Те за жалост са различни на различните машини.) Първите 31 символа са контролни знаци. Останалите са printable или визуални знаци. Знаците които лично аз си правя труда да помня са 32 = 'празно място', 48-57 = 0-9, 97-122 = a-z, но не е наложително, понеже винаги може да се погледне в таблицата

. Повече за нея
тук или на английската версия (по-подробна е) ето
тук.
float (идва от floating point / плаваща точка)
float е тип който се използва за десетични дроби. Неговата големина е 4B. Десетичните дроби във float са представени с мантиса и експонента. Манисата се мени от 0 до 1, а експонентата е степен на която се вдига 10 и се умножава по мантисата. Например 12.5 има мантиса 0.125 и експонента 2 (0.125 * 10^2 = 12.5) и 0.03 има мантиса 0.3 и експонента -1 (0.3 * 10^(-1) = 0.3 * 0.1 = 0.03). Когато ги използвате обаче, това не трябва да ви интересува, защото могат да се използват и както сме свикнали, (0.03 не е грешно, но може да бъде записано и като 0.3е+1). Точността на float обикновенно е прибилизтелно 3 знака след десетичната точка. Приблизително, защото понякога се получават малки отклонения, като например вместо 3.0 получите 2.999.
Върху променливи от тип float могат да се използват следните операции: +, -, *, /. Всички те са еквивалентни на това, което очакваме. 2.0 + 3.2 = 5.2. 4.1 - 1.4 = 2.7. 3.1 * 0.3 = 0.93. 5.0/2.0 = 2.5.
double (идва от double / двоен)
double също е тип за десетични дроби. Неговата големина е 8B или 64bit, и точността му е 2 пъти по-голяма от тази на float. Аритметичните операции са същите, като при float.
Как се декларират променливи от определен тип? Пише се името на типа, и след него името на променливите, които искаме да декларираме от този тип. (декларирането е нужно, ако искаме да ползваме някоя променлива). Ето пример:
short age, height;
double weight;
char gender;
Могат да се добавят и допълнителни запазени думи пред променливите, които ги променят. Например запазената дума
unsigned променя диапазона на стойности които може да приема променливата, като го прави такъв че да съдържа само положителни стойности. Например променлива от тип
unsigned short ще приема стойности от 0 до 65535 вместо от -32768 до +32767.
Запазената дума
const превръща променливата в константа. Това означава, че програмата не може да я променя. Ако искате да създадете константа е нужно при декларирането и да я ициализирате, което става с операторът =.
const double PI = 3.14169265;
Можете ако желаете да инициализирате и променливи, което става по идентичен начин. Запазената дума
long служи за 'разширяване на типа'. Можете да я ползвате само с double и long.
long long e целочислен тип с големина 8B или 64bit, а long double е десетична дроб, заемаща памет 12B или 96bit.
ИнициализациятаАко пишете по-големи и сложни програми е хубаво винаги да си инициализирате променливите, защото ако се опитате да ги променяте преди да сте ги инициализирате ще се получат безсмислици и програмата няма да върви както се очаква.
Операции върху променливитеОперациите се извършват както обичайно. ако искате да съберете две променливи и да запишете резултата в трета трябва да направите следното:
int a = 3,b,c;//декларирате a, b и c и инициализирате а със стойност 3
b = 6; //присвоявате на b стойността 6.
c = a + b; //присвоявате на c стойността на a + b.
Освен аритметичните, можете да извършвате още булеви/логически или побитови операции. Булевите/логическите оператори, които можете да прилагате върху променливи са грубо казано сравнения. Булевите оператори са < (по-малко), > (по-голямо), <=(по-малко или равно), >=(по-голямо или равно), ==(логическо равно (да не се бърка с =)), !=(различно от или не-равно). Логическите оператори се използват като обикновенни и връщат стойност 0 или 1 съответно 1 при вярно и 0 при невярно. Например
int a, b = 3, c = 4;
a = b > c; //тук на а се присвоява стойност 0, защото b не е по голямо от c
a = b <=c; //а = 1, защото b е по-малко или равно на c;
a = b == c; //a = 0, защото b не е равно на c;
a = b != c; //a = 1, по същата причина
Още две логически операции са || и &&. За разлика от останалите те могат да се използват върху булеви изрази или това което правехме преди 2 реда. || или логическо OR връща 1 ако един от двата израза е 1, а другия 0 или ако и двата са 1 и 0 ако и двата са 0. && или логическото AND връща 1 ако и двата израза са 1 и 0 ако поне един от тях е 0. Пример:
int a, b = 3, c = 3;
a = b >= c && b <= c; //един изватен начин да проверите дали b е равно на c, ако b e по-голямо или равно на c и същевременно е по-малко или равно на c то b = c :)
a = b < c || b > c; //това пък е изватен начин да проверите дали b e различно от c
Побитовите операции, могат да ви се сторят странни и излшни в началото.Те са <<, >>, &, |, ^, ~.
<< премества битовете на променливата от лявата му страна на ляво с толкова колкото е променливата от дясната страна.
>> e идентично, само че надясно. Пример:
int a = 7;
a = a << 1; // вече а е 14. 7 в двоична бройна система е 111. Като изместим битовете на ляво с 1 се получава 1110, което е 14.
а = а >> 2; // вече а е 3. досега е било 1110, като преместим битовете на дясно с 2 се получава 11, което е 3.
Ако сте внимавали може да сте забелязали че с това преместване на битовете всъщност умножаваме или делим едно число със степен на 2. Това всъщност е много по-бързо от колкото ако използваме операторът *, поради простата причина че "компютеро работи с еденици и нули', както всички знаят

.
| побитовото OR (не трябва да се бърка с логическото || OR)
скужи за OR-ване на две числа

по-лесно се обяснява с пример.
Имаме 00001111 и 0111100, като ги OR-нем, там където има 1 поне при едното число получаваме 1 в резултата. А ако и 2-те са 0-и се получава 0.
Та OR-ваме и получаваме
00001111
0111100
00111111
& побитовото AND (и то не трябва да се бърка с логическото && AND) служи за AND-ване на 2 числа. Там където има 0 поне при едното число получаваме 0 в резултата, иначе 1. Ако AND-нем пак същите числа ще получим:
00001111
0111100
00001100
^ побитово XOR, него за жалост няма с какво да го сбъркате

служи за (познайте) XOR-ване на 2 числа. Там където има 0 и 1 или 1 и 0 резултатът е 1, а където има 0 и 0 или 1 и 1 е 0. XOR-ваме:
00001111
0111100
00110011
~ тилда, обръща битовете на 1 число. ~111100 = 11..11
000011. Единиците в началото са обърнатите 'невидими' нули на 111100. общо 1-ците и обърнатата 'видима' част от числото са толкова на брой, колкото е и големината на типа в битове. Тоест ако 111100 е от тип int (32 bit) -> 111111111111111111111111111111000011.
Толкова за типовете, променливите и другите такива работи

Ето една примерна програмка, която можете да си реализирате:
#include <stdio.h>
const double PI = 3.14169265;
int main () {
int r;
scanf ("%d", &r);
double S = PI * r * r;
printf ("%lf", S);
return 0;
}
'Програмата' чете от клавиатурата радиуса на една окръжност и пресмята лицето й. Новото тук е функцията scanf, за нея в следващия пост.
Поупражнявайте се с наученото и ако имате въпроси да питате.
Модератор: Темата беше разчистена с цел да се запази четливостта.