Programmer’s Reference


ГЛАВА 1 - Типове данни,променливи и константи



страница2/19
Дата21.09.2016
Размер2.35 Mb.
#10416
1   2   3   4   5   6   7   8   9   ...   19

ГЛАВА 1 - Типове данни,променливи и константи

C и C++ предлагат на програмиста богат асортимент от вградени типове данни . Програмистки-дефинираните типове данни могат да бъдат създадени да стават навсякъде където трябва . Също възможно е да определите константи от вградените в C/C++ типове . В тази глава са описани разнообразни черти отнасящи са до типовете данни , променливите и константите.


Основни типове

C дефинира 5 основни вградени типове данни:


Тип ключова дума

Символ char

Цяло число int

Число със плаваща точка float

Двойно число със плаваща double

точка


Без стойност void

C++ добавя два:



Тип ключова дума

Булев(true/false) bool

Широко-символен wchar_t
Няколко от тези типове могат да бъдат модифицирани чрез използване на един или повече от тези модификатори за тип:
signed unsigned short long

Типовите модификатори предшестват името на типа което изменят. Всички вградени типове данни включително модификатори позволени в C и C++ са показани в следващата таблица заедно със техните минимални гарантирани интервали.Повечето компилатори ще превишават минимума за един или повече типове.Също ако вашия компютър използва два комплекта аритметика(както повечето правят), тогава най-малката отрицателна стойност която може да бъде съхранена чрез цяло число със знак ще бъде със 1 повече от показания минимум.Например интервала на int за повечето компютри –32 768 до 32767.Дали типа char е със знак или е без знак е в зависимост от изпълнението.


Тип минимален интервал


bool true/false

char -127 до 127 или 0 до 255

unsigmed char 0 до 255

signed char -127 до 127

int -32 767 до 32 767

unsigned int 0 до 65 535

signed int също като int

short int също като int

unsigned short int 0 до 65 535

signed short int също като short int

long int -2 147 483 647 до

–2 147 483 647



signed long int също като long int

unsigned long int 0 до 4 294 967 295

float 6 цифрова точност

double 10 цифрова точност

long double 10 цифрова точност

wchar_t също като unsigned int.
Когато модификатора за тип е използван сам се предполага int.Например вие може да определите unsigned int като просто използвате ключовата дума unsigned.Така тези декларации са еквивалентни :

unsigned int i;

unsigned i ; // тук int е по подразбиране

Деклариране на променливи


Всички променливи трябва да бъдат декларирани преди употреба.Общата форма за деклариране е:

тип име_на_променлива;

Напринмер за да декларирате х да бъде float ,y да бъде int и ch да бъде символ вие трябва да напишете :

float x ;

int y ;

char ch ;

Вие може да декларирате повече от една променлива от тип чрез използване на разделен със запетайки списък.Например следващия израз декларира три цели числа :



int a , b , c ;

Инициализиране на променливи

Променлива може да бъде инициализирана чрез следващ след нейното име знак за равенство и начална стойност.Например тази декларация присвоява на count начална стойност 100:

int count = 100;

Инициализатор може да бъде всеки валиден израз когато е декларирана променлива . Това включва други променливи и функции.Обаче във C глобалните променливи и static локални променливи трябва да бъдат инициализирани чрез изрази само от константи .


Идентификатори

Променливи , функции и потребителски дефинирани имена на типове са примери за идентификатори . В C/C++ идентификаторите са поредица от букви ,цифри , и подчертавания със един или няколко символа дължина(идентификатора не може да започва обаче с цифра).Идентификаторите могат да имат всякаква дължина , но в C само първите 31 символа са гарантирано от значение .Подчертаването е често използвано за яснота ,като first_time или за начало на име като _count. Главните и малките букви се приемат за различни. Например test и TEST са две различни променливи. C++ резервира всички идентификатори които започват със две подчертавания или подчертаване следвано от главна буква .




Класове

Класът е основната част в капсулирането на C++. Класът е дефиниран чрез използването на ключовата дума class . Класовете не са част от езика C .Класа е основата си сбирка от променливи и функции които манипулират тези променливи .Променливите и функциите които оформят класа са наречени членове .Общата форма на class е показана тук:

class име­­_на_клас : списък- с- наследявания {

// членове private по подразбиране

protected:

// членове private които могат да се наследяват

public:

// членове public

} списък от обекти;

Tук име_на_клас е името на класовия тип. Веднъж когато декларацията на класа бъде съставена , име_на_клас става нов тип име за данни което може да се използва за деклариране на обекти от класа .Списъка с обекти е разделен със запетайки списък от обекти от тип име_на_клас.Този списък е по избор. Обектите класове могат да бъдат декларирани по-късно във вашата програма просто чрез използване на името на класа .Списъка с наследявания е също по избор . Когато е представен ,той определя базовия клас или класовете които наследява новия клас.(Виж предстоящата секция озаглавена "Наследяване") Класа може да включва функция конструктор и функция деструктор ( и двете са по избор ). Конструктора се извиква когато се създава първи обект от класа .Деструктора се извиква когато се разрушава обект. Конструктора има същото име като класа . Деструктора има същото име като класа но предшествано със ~ (тилда).Нито конструктора нито деструктора имат връщани типове. В класовата йерархия , конструкторите се изпълняват по ред на наследяването, а деструкторите се изпълняват в обратен ред. По подразбиране всички елементи на класа са private за този клас и могат да бъдат достъпни само за другите членове на този клас.За да позволите на елемент от класа да бъде достъпен за функции които не са членове на класа , вие трябва да го декларирате след ключовата дума public . Например



class myclass {

int a , b ;

public:

// членове на клас достъпни за нечленове

void setab ( int I , int j ) { a=I ; b=j ; }

void showab() {cout<< a<<’ ‘<

};

myclass ob1, ob2;

Тази декларация създава тип клас наречен myclass които съдържа две private променливи a и b. Той също съдържа две public функции наречени setab() и showab().Фрагмента също декларира два обекта от тип myclass наречени ob1 и ob2. За да позволите на елемент от класа да бъде наследен , но иначе да бъде private , определете го чрез protected. Protected члена се съдържа във производния клас но е private в неговата класова йерархия. Когато оперирате със обект от клас използвайте оператора точка(.) за обръщане към индивидуалните членове .Оператора стрелка(->) се използва когато достъпвате обект чрез указател . Например следващия код достъпва функцията putinfo() от ob използвайки оператор точка и функцията show() използвайки оператор стрелка:

struct cl_type{

int x;

float f;

public:

void putinfo ( int a, float t) { x= a; f = t;}

void show () {cout<< a <<’ ‘<

};

cl_type ob, *p;

//…

ob.putinfo(10 , 0.23);

p = & ob; // слага адреса на ob в p

p->show(); // показва данните във ob

Възможно е да създадете шаблонни класове използвайки ключовата дума template (Виж “template” във “Справочника на ключовите думи”)



Наследяване

В C++ , един клас може да наследи характеристиките на друг .Наследения клас е обикновенно наречен базов клас .Наследяващия клас е представен като производен клас. Когато един клас наследява друг се формира класова йерархия .Общата форма за наследяване на клас е:

class име_на­_клас : достъп име_на_базов_клас {

// ….

};

Тук ,достъп определя как се наследява базовия клас и той трябва да бъде или private,public или protected .(Той също може да бъде пропуснат и в този случай се приема че е public ако базовия клас е struct , или private ако базовия клас е class.За да наследите повече от един клас , използвайте разделен със запетайки списък.Ако достъп е public , всички public и private членове от базовия клас стават public и protected членове на производния клас .Ако достъп е private ,всички public и protected членове на базовия клас стават protected членове на производния клас.В следващата класова йерархия derived наследява base като private .Това значи че i става private член на derived:



class base{

public:

int i ;

};

class derived : private base{

int j;

public:

derived (int a) {j =i = a;}

int getj ( ) { return j ; }

int geti ( ) { return i ; } // ОК derived има достъп до i

};

derived ob(9); //създава обект derived

cout << ob.geti ( ) << ob .getj ( ) ;

// ob.i = 10 ; // ГРЕШКА i е private за derived


Структури

Структура се създава чрез използване на ключовата дума struct .В C++ структура също дефинира клас .Единствената разлика между class и struct е че по подразбиране всички членове на структурата са public .За да направите член private , вие трябва да използвате ключовата дума private .Общата форма за деклариране на структура е тази :



struct име_на_структура : списък с наследяване {

// public членове по подразбиране

protected:



// private членове които се наследяват

private:



// private членове

} списък- със- обекти;

В C , няколко ограничения са приложени за структурите. Първо те могат съдържат само членове-данни ; член-функции не са разрешени. C-структурите не поддържат наследяване. Също всички членове са public и ключовите думи private и protected не се използват.

Обединения


Обединение е тип клас в които всички членове- данни споделят едно и също място в паметта .В C++ ,обединението може да включва и член-функции и данни. Всички членове на обединението са public по подразбиране . За да създадете private елементи, вие трябва да използвате ключовата дума private. Общата форма за деклариране на обединение е:

union име­_на_клас{



// public членове по подразбиране

private:



// private членове

} списък с обекти;

В C , обединенията могат да съдържат само членове-данни и ключовата дума private не се поддържа. Елементите на обединението се припокриват .Например:

union tom{



char ch;

int x;

} t;

декларира обединение tom, което изглежда така в паметта (приемаме 2-байтово цяло число)

Като класа отделните променливи които съставят обединението се достъпват чрез използване на оператора точка. Оператора стрелка се използва с указател към обединение.Има няколко ограничения които се прилагат за обединенията Първо обединение не може да наследи никакъв друг клас от никакъв тип. Обединение не може да бъде базов клас. Обединение не може да има виртуални член-функции. Никакви членове не могат да бъдат декларирани като static.Обединение не може да има като член обект които предефинира оператора =. Накрая никакъв обект не може да бъде член на обединение ако класа на обекта точно определя коструктор или деструктор функции (обектите които имат само подразбиращи се конструктори и деструктори са разрешени). Има специален тип обединение в C++ наречено анонимно обединение.Декларацията на анонимното обединение не съдържа име на клас и никакви обекти от това обединение не са декларирани .Вместо това анонимното обединение просто казва на компилатора че неговите член-променливи споделят едно и също място в паметта .Обаче обръщането към променливите става директно , без използване на нормалния синтаксис със операторите точка и стрелка .Променливите които правят анонимното обединение са на същото ниво на видимост като всяка друга променлива декларирана в същия блок. Това предполага че имената на променливите в обединението не трябва да влизат в конфликт със никакви други имена които са валидни в техния обсег. Тук е пример за анонимно обединение:

union { // анонимно обединение

int a;

float f;

};

a =10;

cout << f ;

Тук а и f споделят едно и също място в паметта. Както можете да видите , имената на променливите в обединението се пишат директно без използване на операторите точка или стрелка . Всички ограничения които се отнасят за обединенията се напълно отнасят и за анонимните обединения. В добавка , анонимните обединения тръбва да съдържат само данни- никакви член-функции не са позволени. Анонимните обединения не могат да съдържат ключовите думи private или protected. Накрая анонимно обединение в обхвата на именовано пространство трябва да бъде декларирано като static.



Програмен съвет


В C++ е общо приета практика да се използва struct когато създаваме структури в C-стил които включват само членове-данни. Class обикновенно е предназначено за създаване на класове които съдържат член-функции. Понякога акронима POD се използва да означи C-стилова структура .POD означава Обикновенни Стари Данни.

Изброявания


Друг тип променлива която може да се създаде е наречена изброяване. Изброяването е списък от именовани целочислени константи . Така типа изброяване е просто спецификация на списък от имена които принадлежат на изброяването. Създаването на изброяване изисква използване на ключовата дума enum. Общата форма на тип изброяване е :

еnum име_на_изброяването { списък с имена} списък с променливи;

Име_на_изброяването е името на типа изброяване. Списъка от имена е разделен със запетайки. Например следващия фрагмент дефинира изброяване от градове наречено cities и променлива c от тип cities .Накрая на нея се присвоява стойността “Houston”:

еnum cities {Houston , Austin , Amarillo} c ;



c = Houston ;

В изброяването стойността на първото (най-отляво ) име е по подразбиране 0, второто име има стойност 1 , третото има стойност 2 и т. н. Въобще , всяко име има стойност със 1 по-голяма от предшествуващото го.Вие можете да дадете на име определена стойност чрез добавяне на инициализация. Например в следващото изброяване Austin ще има стойност 10:

enum cities {Houston, Austin =10 ,Amarillo} ;

В този пример ,Amarillo ще има стойност 11 понеже всяко име ще бъде със 1 по-голямо от това пред него . В C++ обект изброяване може да присвоява само онези стойности които са дефинирани в неговия тип изброяване. В C на обект изброяване може да бъде присвоена всякаква целочислена стойност.




C тагове


В C имената на структурите , обединенията и изброяванията не дефинират пълно име на тип. В C++ това е така. Например следващия фрагмент е валиден за C++ , но не и за C :

struct s_type {

int i;

double d;

};

// …

s_type x ; // OK за C++ , но не и за C

В C++, s_type дефинира пълно име на тип и може да бъде използвано само за деклариране на обекти. В C ,s_type само дефинира таг. В C вие трябва да поставите пред тага или struct ,union или enum когато декларирате обекти. Например:

struct s_type x; // сега е ОК за С

Този синтаксис е също разрешен в С++ но е рядко използван.



Спецификатори на класове за съхранение


Спецификаторите за съхраняване extern,auto, register, static и mutable се използват за променяне на начина по който С/С++ съхранява променливите. Тези спецификатори предхождат името на типа който модифицират.

extern


Ако спецификатора extern е поставен преди име на променливата , компилатора ще знае че променливата има вътрешно свързване. Външното свързване значи че обекта е видим извън неговия файл. Всъщност ,extern казва на компилатора типа на променливата без в действителност да заделя съхранител за нея. Модификатора extern е най-често използван когато имаме два или повече файла споделящи еднакви глобални променливи.

auto


Спецификатора auto казва на компилатора че локалната променлива която следва е създадена при влизането в блок и се разрушава при излизането от блок. Откакто всички променливи дефинирани вътре във функциите са auto по подразбиране , ключовата дума auto е рядко (ако дори) използвана.

register


Когато беше създаден С ,register можеше само да бъде използван върху локални целочислени илисимволни променливи понеже той беше причина компилатора да направи опит да пази променливата в регистрите на CPU вместо да ги поставя в паметта . Това правеше всички извиквания на променливата извънредно бързи. Дефиницията на register оттогава беше разширена .Сега всяка променлива може да бъде определена като register и е работа на компилатора да оптимизира достъпа до нея. За символите и целочислените , това още означава използване на кеш паметта ,например.Запомнете че register е само заявка. Компилатора е свободен да я отхвърли. Причината за това е че ограничен брой променливи могат да бъдат оптимизирани за скорост. Когато този лимит бъде надвишен, компилатора просто игнорира по нататъшните register заявки.

static


Спецификатора static инструктира компилатора да пази променлива в съществуване през цялото действие на програмата вместо да я създава и разрушава всеки път когато влиза и излиза от обсега. По този начин правейки локални променливи static позволяваме да поддържат техните стойности между извикванията на функциите .Модификатора static може да бъде приложен към глобални променливи .Когато това е направено , то е причина за ограничаване обхвата на променлива във файла в който е декларирана .Това значи че тя ще има вътрешно свързване . Вътрешно свързване значи че идентификатора е известен само във неговия собствен файл. В С++ ,когато static е използвана върху членовете-данни на клас причинява само едно копие от този член да бъде разделен между всички обекти от този клас.

mutable


Спецификатора mutable е приложен само в С++. Той позволява на член на обект да предефинира константността. Така mutable член на const обект не е const и може да бъде изменян.

Типови определители

Типовите определители const и volatile доставят допълнителна информация за променливите които предхождат.


const


Обектите от тип const не могат да бъдат променени от вашата програма през изпълнението й . Също обект указван чрез const указател не може да бъде изменян . Компилатора е свободен да постави променливите от този тип в ROM паметта. const променлива ще получи стойност или от изрична инициализация или чрез някакъв хардуерно- зависим начин. Например :

const int a = 10 ;

Ще създаде цяло число а със стойност 10 която не може да бъде изменена от вашата програма . Тя може обаче да бъде използвана обаче в други типове изрази.


Програмен съвет


Ако класова член функция е модифицирана със const ,тя не може да промени обекта който извиква функцията . За деклариране на const член функция сложете const след нейния списък с параметри. Например:

class MyClass{



int i;

public:

// функция const



void wrong (int a) const {

i = a ; // Грешка! Не можете да изменяте извикващия обект

}



void right (int a) {

i = a; //OK, не е const функция

}

};

както подсказват коментарите , wrong( ) е const функция и тя не може да измени обекта който я извиква.




volatile


Модификатора volatile казва на компилатора че стойностите на променлива могат да бъдат променени по начини не точно определени от програмата. Например адреса на глобална променлива може да бъде подаден по часовников начин от операционната система и да се изменя със всеки цикъл на часовника .В тази ситуация съдържанието на променливата се променя без никакъв ясен присвояващ израз в програмата .Това е важно понеже компилаторите понякога автоматично оптимизират определени изрази допускайки че съдържанията на променливи са непроменени вътре в израза.Това е направено за постигане на по-висока производителност. Модификатора volatile ще предотврати тази оптимизация в онези редки ситуации в които това предположение е вярно.

Масиви

Вие може да декларирате масиви от всякакъв тип данни. Общата форма на едномерен масив е:

тип име_на_променлива [размер] ;

Където тип определя типа данни на всеки елемент в масива и размер определя броя на елементите в масива .Например за да декларирате целочислен масив x от 100 елемента вие ще трябва да напишете:

int x[100];

Това ще създаде масив който е 100 елемента дълъг със първи елемент 0 и последен 99. Например следващия цикъл ще зареди числата от 0 до 99 в масива x:

for ( t = 0; t< 100 ; t++)

x [t] = t;

Вие може да декларирате масиви от всеки валиден тип данни, включително класовете които създавате. Многомерни масиви се декларират чрез поставяне на допълнителни размери вътре в допълнителни скоби . Например за деклариране на 10x20 масив вие трябва да напишете :

int x[10 ] [ 20 ];

Масивите могат да бъдат инициализирани чрез използване на заграден в скоби списък от инициализатори .Например :

int count [5] = {1,2,3,4,5 };


Дефиниране на нови типове имена използвайки typedef


Вие може да създадете ново име за съществуващ тип използвайки typedef. Неговата обща форма е :

typedef тип ново_име ;


Например следния фрагмрнт от код казва на компилатора че feet e друго име за int:

typedef int feet;

Сега следвашата декларация е напълно позволена и създава целочислена променлива наречена distance:



feet distance ;

Константи

Константите също наречени литерали се отнасят за фиксирани стойности които не могат да бъдат променени от програмата. Константи могат да бъдат всякакви основни типове данни .Начина по който се представя всяка константа зависи от нейния тип. Символните константи са затворени между единични кавички.Например ‘а’ и ‘t’ са две символни константи. Целочислените константи се определят като числа без дробни части . Например 10 и -100 са целочислени константи. Константите със плаваща точка изискват употребата на десетична точка следвана от дробната част на числото. Например 11.123 е константа със плаваща точка .Вие също можете да използвате научно означение на числата със плаваща точка. Има два типа със плаваща точка : float и double. Също има няколко вида от основните типове които се получават чрез използване на модификаторите за тип. По подразбиране компилатора поставя числовите константи във най- малкия съвместим тип данни който ще ги съдържа. Единственото изключение от правилото за най- малкия тип са константите със плаваща точка , които се приемат да са от тип double. За повечето програми подразбирането на компилатора е напълно достатъчно . Обаче е възможно да определите точно типа на константата която искате. За определяне точния тип на числова константа използвайте суфикс. За типовете със плаваща точка ако сложите след числото F то ще се третира като float. Ако го последвате със L числото става long double. За целочислените типове суфикса U се разбира за unsigned и L за long. Няколко примера са показани тук:



тип данни Примери за константи

int 1 123 21000 -234



long int 35000L -34L

unsigned int 100000U 987U

float 123.23F 4.34e-3F

double 123.23 -0.987324

long double 1001.2L

Шестнайсетични и осмични константи


Понякога е по- лесно да използвате числова система базирана на 8 или 16 вместо 10 . Числовата система базирана на 8 е наречена осмична и използва цифрите от 0 до 7 . В осмичната числото 10 е същото като 8 в десетичната. Базираната на 16 числова система е наречена шестнайсетична и използва цифрите от 0 до 9 плюс буквите от А до F които означават 10, 11,12, 13, 14 и 15 . Например шестнайсетичното число 10 е 16 в десетичната . Понеже често тези две числови системи се използват С/С++ ви позволява да определите целочислени константи в шестнайсетична или осмична вместо в десетична ако предпочитате. Шестнайсетичните константи трябва да започват със 0x(нула следвана от х) или OХ следвана от константата във шестнайсетична форма . Осмична константа започва с 0. Тук са два примера :

int hex = 0x80; //128 в десетична

int oct = 012 ; //10 в десетична

Низови константи


С/С++ поддържа един друг тип константа в добавка към тези предефинирани типове данни : низ. Низа е множество от символи затворено в двойни кавички(” ”). Например “this is a test” е низ. Вие не трябва да бъркате низовете със символите . Единична символна константа е затворена между единични кавички такава като ‘а’. Обаче “а” е низ съдържащ само една буква. Низовите константи се автоматично терминират със 0 от компилатора. С++ също поддържа и клас string , който е описан по- късно в тази книга.

Булеви константи


С++ определя две булеви константи : true и false.

Константи след обратно наклонена черта


Заграждането на символни константи в единични кавички работи за повечето печатни символи , но някой такива като връщане на каретката е невъзможно да бъдат въведени във вашия програмен сорс код от клавиатурата. По тази причина С/С++ разпознава няколко константи след обратно наклонена черта също наречени escape последователности. Тези константи са изброени тук:

Код Значение

\b Backspace



\f Връщане в началото на реда (formfeed)

\n Нов ред

\r Връщане на каретката



\t Хоризонтална табулация

\ Двойни кавички

\’ Единични кавички

\\ Обратно наклонена черта

\v Вертикална табулация

\a Сигнал от високоговорителя



\N Осмична константа( където N e осмичната константа)

\xN Шестнайсетична константа ( където N e шестнайсетичната константа)

\? Знак ?

Константите след обратно наклонената черта могат да бъдат използвани навсякъде където могат и символите . Например следващия израз извежда нов ред и табулация и тогава отпечатва низа “This is a test”:

cout << “\n \t This is a test”;


Каталог: books
books -> Тайнствената сила на пирамидите Богомил Герасимов Страхът на времето
books -> В обятията на шамбала
books -> Книга се посвещава с благодарност на децата ми. Майка ми и жена ми ме научиха да бъда мъж
books -> Николай Слатински “Надеждата като лабиринт” София, Издателство “виденов & син”, 1993 год
books -> София, Издателство “Българска книжница”, 2004 год. Рецензенти доц д. ик н. Димитър Йончев, проф д-р Нина Дюлгерова Научен редактор проф д-р Петър Иванов
books -> Николай Слатински “Измерения на сигурността” София, Издателство “Парадигма”, 2000 год
books -> Книга 2 щастие и успех предисловие
books -> Превръщане на числа от една бройна система в друга
books -> Тантриското преобразяване


Сподели с приятели:
1   2   3   4   5   6   7   8   9   ...   19




©obuch.info 2024
отнасят до администрацията

    Начална страница