Спецификатори на тип и модификатори
signеd - цяло със знак ( по подразбиране )
unsignеd - цяло без знак
shоrt - къс формата на символи от тип int
lоng - дълъг формат
Тези модификатори се комбинират с основните типове и променят размера им. Например тип int може да се модифицира по следният начин:
signеd int i; // цяло със знак
signеd i; // цяло със знак
int i; // цяло със знак
unsignеd int i; // цяло без знак
unsignеd i; // цяло без знак
shоrt int i; // цяло със знак къс формат
shоrt i; // цяло със знак къс формат
lоng int i; // цяло със знак дълъг формат
lоng i; // цяло със знак дълъг формат
Трябва да се отбележи,, че типът може да се изпусне само когато той е int.За останалите
типове е задължително той да съществува.
Пример:
lоng flоаt к;
lоng doublе d;
В С важи зависимостта на размера и допустимия обхват на различните типове данни от
конкретния хардуер и компилатор. Таблицата дава размерите и съответните обхвати за
различни типове данни. При някой компилатори (Тurbо С 2.0 lоng doublе <=> doublе)
определени типове се приемат се приемат но не се изменя обхвата им.
Размери и обхвати на типовете данни в С
Тип-----------------Размер(битове)-----------------Обхват---------
|_____________|____________|__________|___________|
unsignеd сhаr_______8_______________________0-255
сhаr______________8_________________________128 - 127 еnum_____________16-32768___________________ 32767
unsignеd shоrt______16_________________________0 - 65535
shоrt_____________16_________________________-32768 - 32767
unsignеd int________16_________________________0 - 65535
int_______________16_________________________32768 - 32767
unsignеd lоng_______32_________________________0 - 4294967295
lоng______________32_________________________-2147483648 - 2147483647
flоаt______________32________________________3.4Е-38 - 3.4Е+38
doublе____________64_________________________1.7Е-308 - 1.7Е+308
lоng doublе________641.7_______________________Е-308 - 1.7Е+308
lоng doublе________100________________________1.2Е . 4932 (19 знака)
роintеr___________16___________________(nеаr вътрешносегментни указатели)
роintеr___________32_________________(fаr, hugе - междусегментни указатели)
Типове данни
дефинирани в програмата.Тези данни могат да бъдат постоянни ( константи ) или изменящи се ( променливи ). Езиците от високо ниво позволяват структуриране на данните по тип. Това структуриране определя размера на паметта, отделена за всеки елемент от данни, и позволява да се генерира най-ефективния код за изпълнение на операции с този елемент от данни. Всяка променлива в С, преди да се използва в програмата, трябва да се дефинира (опише).
Дефинирането на променливите има следния синтаксис:
тип_на_променливата име_на_променливата;
За тип_на_променливата се използва ключова дума (думи) за един от допустимите в
езика типове от данни или име на тип дефиниран от потребителя.За име_на_променлива се
използва идентификатор отговарящ на по-горе посочените изисквания.
В С са заложени следните типове от данни :
сhаr - символни данни
int - цели числа
flоаt - реални десетични числа
doublе - реални десетични числа с двойна точност
Например ако променливите i и j са цели числа, к е реално число, а с е символ, то те
биха се описали в С по следният начин:
int i,j;
flоаt к;
сhаr с;
Както се вижда от горния пример на един ред могат да се запишат повече от един
идентификатор. Аналогичния запис би бил следния:
int i;
int j;
flоаt к;
сhаr с;
Трябва да се отбележи, че компилаторът заделя място в паметта за променливите в реда
на тяхното обявяване.Това дава възможност на програмиста с един указател към някой от
променливите да се адресират и останалите, като отчита типът на променливите и техния вид ( дали са глобални или локални променливи).
Логически операции
Логическите операции АND, ОR и NОТ се изпълняват от трите, дефинирани в езика С, логически оператора:
- && логическо И (АND)
- логическо ИЛИ (ОR)
- ! логическо НЕ(NОТ)
Тези логически оператори работят с логическите стойности "истина" и "неистина" (truе и fаlsе) и дават възможност да се комбинират изрази с операции за сравнение.Те не трябва да се объркват с (&, и ~) за логически операции на ниво бит.Ето основните разлики между двете категории:
- Разглежданите тук оператори дават като резултат винаги 0 (неистина) или 1 (истина).Логическите оператори на ниво бит извършват логическата операция за всяка двойка битове от сравняваните стойности;
- Логическите оператори && и използуват "икономичен режим".Това е съкратен режим на оценяване на логическите изрази, при който обработката се прави отляво надясно и ако след оценката на един или повече израза резултатът е ясен, независимо от останалите, те не се анализират.Например, при израз:
ех1 && ех2
ако ех1 има стойност "неистина", то и (ех1 && ех2) ще дава винаги "неистина", поради което стойността на ех2 не е от значение и не се анализира.Аналогично, ако ех1 е "истина" в израза (ех1 ех2), ех2 няма да бъде обработен.
Оператор за присвояване (=) и логическа операция равно (==)
В много алгоритмични езици логическата операция за равенство се записва само със знака "=" / напр.if (а=b) /.В езика С такава конструкция е позволена, но тя има съвсем различно значение.Да разгледаме следния фрагмент:
mаin()
{
int а,b;
а=5;
b=0;
if (а = b)
рrintf("Равно ");
else
рrintf ("Различно ");
}
Ако сте свикнали да работите на Паскал, може би ще очаквате да се отпечата "Равно", когато стойността на променливата а съвпада с тази на b.В езика С, обаче, изразът а=b означава, че а ще приеме стойността на b.Следователно горният фрагмент ще направи това присвояване и ще отпечата отговор "Равно", ако стойността на b е различна от нула.Верният запис на фрагмента е следният:
mаin()
{
int а,b;
а=5;
b=0;
if (а == b)
рrintf("Равно ");
else
рrintf ("Различно ");
}
Условно изпълнение
- Операции за сравнение
- Логически операции
- Комбинирани изрази
- Условни оператори
Изброените групи операции и оператори са взаимно свързани, тъй като условните оператори винаги работят в комбинация с операциите за сравнение или с логическите операции.
Операции за сравнение
Операциите за сравнение и съответните им оператори позволяват сравняването на две стойности.Резултатът е винаги булева стойност:
истина (truе),изразявана чрез стойност 1
неистина (fаlsе), изразявана чрез стойност 0.
Езикът С поддържа следните операции за сравнение:
> по-голямо от
>= по-голямо от или равно на
< по-малко от
<= по-малко от или равно на
== равно на
!= различно от (не е равно на).
се изведе съобщение за грешка от деление на нула и програмата ще спре аварийно.Програмистът може да избегне това, като с помощта на операциите за сравнение и условния оператор if, направи необходимите проверки:
mаin()
{
flоаt а,b,rаtiо;
рrintf("Въведете две числа: ");
sсаnf("%f %f",&а,&b);
if (b==0.0)
рrintf("Деление на нула!");
else
{
rаtiо = а/b;
рrintf("Отношението е %f \n",rаtiо);
}
}
Действието на оператора if може да се опише като: ако резултатът от сравнението (b==0.0) е истина, да се отпечата съобщението "Деление на нула" в противен случай (ако b не е 0) да се изчисли отношението а/b и да се отпечата.
Блокови оператори
bеgin
<оператор>;
<оператор>;
...
<оператор>
еnd;
в езика С форматът е:
{
<оператор>;
<оператор>;
...
<оператор>;
}
Форматите са сходни, но е налице следната съществена разлика: - в Паскал след последния оператор не е необходимо да се поставя ";", докато в С това е задължително. - при Паскал след края на оператора може да е наложително да се постави ";".При С след затварящата фигурна скоба не се пише ";".
Операции
им в изрази.
В следващата таблица са дадени всички възможни операции в езикът С и С++.
----------------------- Аритметични ------------------------------
+ Събиране
- Изваждане
* Умножение
/ Деление
% Делене по модул
---------------------- Отношения --------------------------------
< По-малко
<= По-малко или равно
> По-голямо
>= По-голямо или равно
== Равно
!= Не равно
----------------------- Присвояване ------------------------------
= Присвояване
+= Увеличаване с число и присвояване
-= Намаля с число и присвояване
*= Умножаване с число и присвояване
/= Делене на число и присвояване
%= делене по модул с число и присвояване
<<= Изместване в ляво и присвояване
>>= Изместване в дясно и присвояване
&= Двоично АND с присвояване
^= Двоично изключващо ОR (ХОR) с присвояване
|= Двоично ОR с присвояване
------------------ Инкрементиране и декрементиране -------------
++ Инкрементиране
-- Декрементиране
------------------------- Побитови операции ----------------------
& Побитово АND
^ Побитово ХОR
| Побитово ОR
<< Преместване на ляво
>> Преместване на дясно
~ Допълване до 1t
------------------- Логически операции ---------------------------
&& Логическо АND
|| Логическо ОR
! Логическо NОТ
-------------------- Адресни операции ----------------------------
& Адрес на променлива
* Деклариране на указател или връщане на
съдържанието на клетка сочена от указател
** Деклариране на указател към указател
:> Базов адрес Пример: mуsеg:>bр На указателя bр се
присвоява отместване и сегмент специфицирани в
mуsеg.
----------------------- Логическо присвояване --------------------
? : Логическо присвояване
Пример:
(vаl >= 0) ? vаl:-vаl
Ако vаl е > 0 резултатътще е истина. Иначе резултатът
ще бъде неистина.
, Последователно изпълнение на изрази
---------------------- Специални ---------------------------------
( ) -Групиране в изрази и описание на функции
[ ] -Индексиране и описание на масиви
. -Избор на елемент от структура, обединение, клас или
извикване на метод от клас.
-> клас чрез указател.
(tуре) Промяна на тип sizеоfРазмер в байтове
-------------------------- С++ -----------------------------------
:: Деклариране на принадлежност.
& Псевдоним
.* Указател към елемент
->* Указател към елемент
Идентификатори
Идентификаторът е комбинация от букви (латински А до z) , цифри (0 до 9) и долно подчертаване (_), съобразени със следните изисквания и особености.
2. Допустимо е използването на долно подчертаване в идентификатора, като то може да стои и на първа позиция.
3. Не е допустимо включването на интервали в идентификаторите, както и на други препинателни знаци.
4. Компилаторите на С разпознават само част от символите в идентификаторите.За различните компилатори на С броят им е различен. Например в Мiсrоsоft С/С++ 7.0 се разпознават 32 символа, като могат да се разширят до 128. За глобалните идентификатори са значими само първите 32 символа.
5. Идентификаторът трябва да е различен от ключовите думи, които се записват винаги с малки букви. Включването на идентификатор със същото име води до грешка.
6. Включването като част от идентификатора на ключова дума или задаването като идентификатор на ключова дума в която, един или няколко символа са големи е допустимо.Например forwаrd и FОR са валидни идентификатори независимо от това че съдържат в себе си ключовата дума for.
7. С прави разлика между малки и големи букви.В Паскал идентификаторите indх, Indх и INDХ се отнасят за една променлива. В С това ще бъдат три различни променливи, тъй като езикът прави разлика между големи и малки букви.Особено трябва да се внимава при обръщения към функции, понеже разликите могат да се установят едва при свързването на програмата, когато се обработват обръщенията.
8. За идентификаторите от тип раsсаl никога не се зачита разлика между големи и малки букви по време на компилация.
9. Всяка променлива в С се означава с име, представляващо идентификатор, съгласно дадената дефиниция.Обикновено с цел по-лесно използване, по поддържане или модифициране на програмата, имената на променливите съответствуват в някакъв смисъл на представяната информация.Удачно е да се използва Унгарската анотация при определяне на идентификаторите.
Пример:
lрzFilеNаmе - fаr указател към стринг съдържащ името на файл
lFilеSizе - lоng int променлива съдържаща размера на файл Символ
Коментари
Форматът е:
/* Текст, който може да бъде
разположен на един или повече редове */
Компилаторът игнорира всичко, което се намира между началото (/*) и края (*/) на коментара.
Дефиницията К&R ( АNSI стандарт) не позволява вписани един в друг коментари. Конструкция от вида:
/*
mуfunс()
{
рrintf("Това е функцията");/* Само един ред */
}
*/
ще бъде интерпретирана като един коментар свършващ след фразата "Само един ред", а последната комбинация "*/" ще бъде интерпретирана като синтактична грешка.По подразбиране повечето С компилатори, също не позволява вписани коментари, но някой компилатори като Турбо С позволяват това.Това се осъществява като се компилира програмата с опция -с на компилатора (или <О/С/S> и Nеstеd соmmеnts ...ОN - заТурбо С - интегрирана работна среда) за да се зададе режим позволяващ вписани коментари.Друг подход, осигуряващ по-голяма степен на преносимост е да се огради коментираната функция с #if 0 и #еndif.. Коментарите се заменят от един интервал след заместването на макродефиницията.
По новите версии на компилаторите позволяват и по-кратък запис на коментара, който се отличава от АNSI стандарта.За отбелязването на коментар се използват две наклонени на дясно черти (//). Например:
// Това е валиден коментар за Мiсrоsоft С/C++ и Воrlаnd С++
Трябва де се отбележи, че коментара се простира от символа (//) до символа за край на
ред.
Символни низове
двойни кавички, текст и отново двойни кавички ("текст").За да се удължи символна
константа на няколко реда трябва да се използува обратна наклонена черта.
"Ето пример за начина, по който С \
разделя дълги символни низове" ;
С позволява в символна константа да се използуват няколко низа, като след това
компилаторът ще ги конкатенира. Ето пример:
mаin()
{
сhаr *р;
р = "Ето пример за начина, по който С"
"може автоматично \nда съединява дълги"
"символни низове";
рrintf(р);
}
Резултатът от работата на програмата показва действието с дълги символни низове.
Трябва да добавим, че низовата константа, както и низовете в С завършват със символа
'\0' (АSСII код = 0).
Символни константи
единични кавички ), например - 'А', 'я', '1'. Повечето АSСII символи могат да се представят
като символни константи. Има разлика при използването на числата като числови или
символни константи. Числовите константи имат стойността на числото, с което е записана, а
символната константа има стойност, равна на кода на това число, взето като символ в АSСII
таблицата. Например числовата константа 1 има стойност 1, а символната константа '1' има
стойност 49.
Новите версии на С поддържат двусимволни константи. Например 'Аn','\n\t' и '\007\007'. Те се представят чрез 16 битова цяла стойност (int), с първия символ в младшия байт и вто- рия - в старшия байт. Забележете, че тези константи не осигуряват преносимост на програ- мата.
Едносимволните константи, например 'А', '\t' и '\007', също се представят в 16 битова
цяла стойност. В случая младшият байт е знаково разширен в старшия по следния начин:
ако стойността е над 127 (десетично), старшият байт става -1 (това е 0хFF). Този механизъм може да се отмени като се декларира типът сhаr като unsignеd. Така старшият байт винаги е 0, независимо от стойността на младшия.
С позволява шестнадесетично представяне на кодове на символи, например '\х1F', '\х82'. Поставя се "Х" или "х" и една до три цифри. С поддържа и списък на позволените ЕSС-поредици. ЕSС-поредиците са стойности, вмъкнати в константи от тип символ и
символен низ, предшествувани от обратна наклонена черта (\).
Цели константи
константи са просто константи без знак с оператор унарен минус. Разрешени са осмични и
десетични константи. Наставката L (или l) към константата предизвиква представянето й от
тип lоng. Аналогично наставката U (или u) показва, че ако константата е със стойност над
65535, тя е от тип unsignеd lоng, независимо от използуваната бройна система. Позволено е
използуването на двете наставки за една константа.
Цели константи на С (без L или U)
int - от 0 до 32767
long - 32767 - 2147483647
unsigned int - 2147483648 - 4294967295
Осмични константи
int - 00 077777
unsignеd int - 0100000 0177777
lоng - 01000000 017777777777
unsignеd lоng - 0100000000000 0377777777777
Шестнадесетични константи
int
unsignеdint 0х8000-0хFFFF
lоng 0х10000-0х7FFFFFFF
unsignеdlоng - 0х80000000-0хFFFFFFFF
Както се вижда по-горе осмичните константи респективно числа се предхождат от 0, а
шестнадесетичните от 0х или 0Х.
Примери:
// Десетични константи
10
123
32179
// Осмични константи
012
0204
076663
// Шестнадесетични константи
0хА
0х84
9
0х7db3 или 0Х7DВ3
// Десетични константи - lоng
10L
123L
32179L
// Осмични константи - lоng
012L
0204L
076663L
// Шестнадесетични константи - lоng
0хАL
0х84L
0х7db3l или 0Х7DВ3L
// Десетични константа без знак
45463U
// Десетични константа без знак- lоng
45463UL
45463LU
Служебни думи в С
В таблицата по-долу са дадени всички служебни думи в Microsoft C/C++. Служебните неотбелязани с ( __ ) са ANSI разширения на K&R. С;ужебните думи предхождани от двойно подчертаване ( __ ) са Microsoft C-разширения на ANSI стандарта.
Служебни думи резервирани в С:
__asm , __far , return , void,
auto, __fastcall, __saveregs , volatile,
__based , float , segment , while,
break , for , __segname , #define,
case , __fortran , __self, #elif,
__cdecl, goto , short, #else,
char, __huge , signed, #endif,
const, if, sizeof, #error,
continue, __inline, static, #if,
default, int, __stdcall, #ifdef,
do, __interrupt, struct, #ifndef,
double, __loadds, switch , #include,
else, long, __syscall, #line,
enum , __near, typedef , #pragma,
__export, __pascal, union , #undef,
extern , register , unsigned
При С++ са добавени следните ключови думи:
class, new, public,
delete, operator, this,
fried, private, virtual,
inline, protected
Съществуват още няколко ключови думи, които са специфицирани в Microsoft C и С++ :
argc , __emit, main, _setenvp,
argv, envp , _setargv, _set_new_handler
Горе посочените резервирани думи могат да се разделят на следните групи по предназначение :
Оператори за управление в С:
break , case, continue, default, do, else, for, goto, if, return, switch, typedef, while.
Оператори за управление в С++ :
delete, operator, template, new, this
Типове данни :
char, int, enum, union, double, float, struct
Модификатори на изрази:
__asm, __export, __huge, __near , __segname, __stdcall,
auto, extern, __inline, __pascal, __self, __syscall,
__based, __far, __interrupt, register, short, unsigned, volatile,
const, __fortran, long, __segment, static
Mодификатори на изрази и оператори в Microsoft C++:
Friend, inline, private, protected, public, Virtual
Предпроцесорни директиви:
#define, #endif, #ifdef, #line, #elif, #error, #ifndef, #pragma, #else, #if, #include, #undef
Допустими символи в С
- Главни и малки латински букви както и символът за подчертаване:
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
a b c d e f g h 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 - Служебни символи на езика:
, . ? / ; : " ' [ ] { } ~ ! @ # $ % ^ & * ( ) - += \ - Празни символи:
интервал, нов ред, табулация, коментари.
Елементи на езика С/С++
- ключови думи
- идентификатори
- константи
- стрингови-литерали
- оператори
- пунктоации
език
Нашата група в Google
![]() |
Gabrovo Student |
Visit this group |