Лекции по структури от данни и програмиране

Четени през зимния семестър на учебната 2002/2003 година. Лектор тогава беше доц. Стоян Бъчваров.

Използвал съм единствено и само мои (и на мои колеги) записки от лекции. Всички програми са компилирани на C++.

1. Вход и изход на потоци. Общи сведения.
стандартните библиотеки в C++ имат разширен набор от средства за вход и изход;

всяка операция за вход и изход в C++ се изпълнява по начин, който зависи от типа на данните; ако за даден тип данни е била дефинирана функция за вход и изход, то именно тя се извиква при обработване на този тип данни; ако няма съответствие между типа на данните и функцията за обработка на този тип данни, компилаторът дава съобщение за грешка; по такъв начин несъответстващите данни не могат да проникнат в системата, както това може да се случи в C, което от своя страна води до възникване на трудно откриваеми грешки;

C++ дава възможност за стандартна обработка на входа и изхода както за вградените типове, така и за типове, дефинирани от потребителя; в C++ се извършва вход и изход на поток от байтове, т.е. на последователност от байтове;

входът и изходът могат да бъдат форматирани или неформатирани, т.е. с преобразуване или без преобразуване; при неформатиран вход и изход се постига максимална ефективност, когато се обработват файлове с голям обем;

библиотеката за вход и изход от потоци е iostream; нейният интерфейс е разбит на няколко заглавни файла:

• 
  заглавният файл iostream.h съдържа основни сведения, които са необходими за всички операции за вход и изход; предвидени са средства за форматирани и неформатирани вход и изход; този заглавен файл включва обектите:
  

cout – съответства на стандартния поток за изход;

cerr – съответства на небуфериран поток за извеждане на съобщения за грешки;

clog – съотвества на буфериран поток за извеждане на съобщения за грешки;

• 
  заглавният файл iomanip.h съдържа информация, полезна за обработката на форматиран вход и изход с помощта на така наречените параметризирани манипулатори на потока;
  
• 
  заглавният файл fstream.h съдържа информация за извършване на операции с файлове;
  
• 
  заглавният файл strstream.h съдържа информация за използване на форматиран вход и изход в паметта; това прилича на обработката на файлове, но операциите за вход и изход се извършват със символни масиви, а не с файлове;
  
• 
  заглавният файл stdiostream.h включва нужните сведения за програми, които използват при изпълнение изпълнение на операциите за вход и изход средства от C;
  

предефинирането на операции позволява удобно записване на операциите за вход и изход;

операцията за изместване вляво << е предефинирана за означаване на изход в поток и се нарича операция за извеждане в поток;

операцията за изместване вдясно >> е предефинирана за означаване на вход от поток и се нарича операция за въвеждане от поток;

тези операции се прилагат към обектите на стандартните потоци cin, cout, cerr, clog и също се използват с обекти на потоци, чийто тип е дефиниран от потребителя;

обектът cin е от клас istream и е свързан със стандартното устройство за вход (обикновено клавиатурата);

обектът cout е от клас ostream и е свързан със стандартното устройство за изход (обикновено екрана на монитора);

операциите за въвеждане от поток и извеждане в поток определят типа на използваните данни; ако типът не е предвиден, т.е. операциите не са предефинирани за този тип, се включват различни флагове за грешки, с помощта на които потребителя може да определи дали операциите за въвеждане и извеждане са били успешни;

обектът cerr е от клас ostream и е свързан със стандартното устройство за извеждане на съобщения за грешки; изведеният поток от данни за обекта cerr е небуфериран, т.е. всяка операция за извеждане в cerr води до незабавно появяване на изведеното съобщение;

обектът clog е от клас ostream и също е свързан със стандартното устройство за извеждане на съобщения за грешки; изведеният поток от данни за обекта clog е буфериран, т.е. всяка операция за извеждане в clog води до съхраняване на изведеното в буфер, докато той не бъде запълнен изцяло или докато съдържимото на буфера не бъде изведено принудително;

• 
  клас ifstream, който изпълнява операции за вход от файлове;
  
• 
  клас ofstream, който изпълнява операции за изход във файлове;
  
• 
  клас fstream, който е предназначен за операции при вход и изход от файлове;
  

• 
  извеждане на данни от стандартни типове, с помощта на операцията за извеждане в поток (<<);
  
• 
  извеждане на символи с помощта на операцията put;
  
• 
  неформатирано извеждане с помощта на операцията write;
  

операцията за изместване наляво стандартно е предефинирана за извеждане на данни от вградени типове, за извеждане на низове и за извеждане стойността на указатели; тази операция може да бъде предефинирана в програмата за извеждане на данни от потребителски типове; възможно е слепване на операцията за извеждане в поток, тъй като тя връща псевдоним на левия си операнд и е ляво-асоциативна;

преминаването на нов ред става с помощта на управляващия символ ‘\n’ или с помощта на манипулатора endl; изпълнението на endl освен това води до незабавно извеждане на съдържимото на буфера; това може да стане и с манипулатора flush;
в езика C++ има функция елемент tie, която се използва за синхронизация, т.е. свързване на изпълнението на операциите с потоци за вход и за изход; функцията tie гарантира, че изведеното ще се покаже преди следващото въвеждане, което е много важно при създаване на интерактивни приложения; за да се синхронизират потока за вход inputStream от клас istream и потока за изход outputStream от клас ostream се използва следния оператор

inputStream.tie (&outputStream);

тази връзка се разпада със следното извикване:

inputStream.tie (0);

в C++ автоматично е създадена такава връзка между cin и cout, т.е.

автоматично се извиква cin.tie (&cout);

операцията << може да се използва за извеждане на данни от тип char* като символен низ, който завършва с нулев байт (‘\0’);

например:

char *string = “Проверка”;

cout << string << endl;

чрез явно преобразуване на типа на указателя string към void* можем да изведем стойността на самия указател string, т.е. адреса на първия символ на низа:

cout << (void *) string << endl;

това се отнася за всеки указател към променлива, ако програмистът иска да изведе нейния адрес;
функцията елемент put извежда един символ; например оператора

cout.put (‘A’);

ще изведе символа ‘A’; извикванията на put могат да бъдат слепени – например:

cout.put (‘A’).put (‘B’);

това е възможно, тъй като операцията ‘.’ е ляво-асоциативна и функцията елемент put връща псевдоним на обекта, за който е била извикана; аргументът на функцията put може да бъде произволен израз, чиято стойност е ASCII код на символ, например:

cout.put (65);

ще изведе символа ‘A’;
неформатиран вход и изход се извършва с помощта на функциите елементи read и write;

функцията елемент read от класа istream въвежда определен брой байтове в символен масив от паметта; тези байтове не се преобразуват; ако са прочетени по-малък брой символи се включва флага failbit;

функцията елемент write от класа ostream извежда определен брой байтове от символен масив в паметта, включително и нулевите байтове; изведените байтове не се преобразуват;

функцията елемент gcount от класа istream връща броя на символите, прочетени от последната операция за вход;

примерна програма:
#include

const int SIZE = 80;

void main ()

{ char buffer[SIZE];

cout << "Въведете изречение: ";

cin.read (buffer, 20);

cout.write (buffer, cin.gcount());

cout << endl;

}
3. Форматиран вход на потоци.
входният поток е разбит на елементи; между елементите има един или повече празни символи (интервал, табулация, символ за нов ред);
операцията за въвеждане от поток (>>) връща нулева стойност, т.е. false, ако срещне в потока символа за край на файла; в противен случай тя връща псевдоним на левия си операнд, т.е. на обекта за който тя е била извикана – това позволява слепване на операцията за въвеждане; операцията за въвеждане включва флага failbit, т.е. задава му стойност 1, при въвеждане на данни от неправилен тип и включва флага badbit при неуспешно завършване на операцията;

типична грешка е да се въвеждат данни от поток от клас ostream или да се извеждат данни в поток от клас istream;

много често операцията за въвеждане от поток се използва като условие в оператор за цикъл; примерна програма:
#include

#include

void main ()

{ double grade, highestgrade = -1;

cout << "Въведете оценка или Ctrl+Z за край: ";

while (cin >> grade)

{ if (highestgrade < grade) highestgrade = grade;

cout << "Въведете оценка или Ctrl+Z за край: ";

}

cout << endl << "Най-високата оценка е: " << setprecision(2) <<

}
изразът cin >> grade може да бъде използван като условие, тъй като производният клас istream наследява от базовия клас ios предефинирана операция за преобразуване на тип поток в указател от тип void*, при това стойността на указателя е 0 (NULL), ако е възникнала грешка при опит за въвеждане на данни или ако е стигнат символ за край на файла; за да може да използва израз от тип void* като условие компилаторът извършва вградено преобразуване на израза към целочислен тип;

• 
  без параметри – функцията въвежда един символ от указания поток, включително и празните символи (‘ ‘, ‘\t’, ‘\n’) и връща този символ като резултат; връща EOF, ако се достигне край на файла; пример:
  

cout << “Въведете низ и Ctrl+Z за край: “;

while ( (c = cin.get()) != EOF) cout.put (c);

• 
  с един параметър от тип char – функцията въвежда един символ от входния поток, включително и празните символи и го присвоява на символния аргумент; тя връща 0, ако се достигне символ за край на файла, а в останалите случаи връща псевдоним на обекта за който е извикана;
  
• 
  с три параметъра – указател от тип char *, максимален брой символи и ограничител, който по премълчаване е ‘\n’; този вариант на get чете символи от входния поток докато техният брой стане с 1 по-малко от зададения брой или докато срещне ограничителя; функцията автоматично добавя нулев байт към низа; ограничителят не се записва в символния масив, а остава във входния поток; пример:
  

#include

const int SIZE = 80;

void main ()

{ char buffer1[SIZE], buffer2[SIZE];

cout << "Въведете изречение: ";

cin >> buffer1;

cout << buffer1 << endl;

cin.get(buffer2, SIZE);

cout << buffer2 << endl;

}
функцията елемент getline има същите параметри като третия вариант на get и действа по същия начин с тази разлика, че тя чете символа ограничител и го премахва, т.е. не го записва в символния масив; пример:

char buffer[80];

cout << “Въведете изречение: “;

cin.getline (buffer, SIZE);

cout << buffer << endl;
функцията елемент ignore приема два параметъра – брой символи и символ ограничител; тя пропуска зададения брой символи (по премълчаване 1) или завършва своята работа при откриване на ограничителя, при това тя го премахва от входния поток; по премълчаване ограничителят е EOF;
функцията елемент putback връща символ обратно във входния поток; обикновено преди това символът е прочетен с get; функцията е полезна за приложения, които преглеждат входния поток с цел търсене на запис, който започва с даден символ; когато този символ е въведен, приложението го връща обратно във входния поток, за да бъде включен в данните, които ще се въведат по-нататък;
функцията елемент peek връща поредния символ от входния поток, включително и празните символи, но не го премахва от потока;
4. Манипулатори на потоци.
манипулаторите на потоци се използват за форматиране; те позволяват да се изпълняват следните операции:

• 
  задаване на минимална ширина на поле;
  
• 
  задаване на точност за числа с плаваща точка;
  
• 
  включване и изключване на флагове на формата;
  
• 
  задаване на запълващ символ на поле;
  
• 
  изчистване на буферите на потоци;
  
• 
  извеждане на символ за нов ред и изчистване на буфера;
  
• 
  извеждане на нулев байт;
  
• 
  пропускане на символите разделители във входния поток;
  

основата на целите числа в поток се задава с манипулаторите:

• 
  dec (decimal) – за десетични цели числа;
  
• 
  oct (octal) – за осмични цели числа;
  
• 
  hex (hexal) – за шестнайсетични цели числа;
  

основата на целите числа в поток може да се зададе и чрез манипулатора setbase, който има един цял параметър, приемащ стойности 8, 10, 16, задаващи съответната основа; тъй като setbase има параметът, той се нарича параметризиран манипулатор; използването на такива манипулатори изисква включването на заглавния файл iomanip.h; основата на бройната система остава една и съща, докато не бъде променена отново; пример:

int n = 20;

cout << n << endl //20

#include

#include

#include

void main ()

{ double root2 = sqrt (2);

for (int i = 0; i <= 9; i++)

{ cout.precision (i);

cout << root2 << endl;

}

}

1.

1.4

1.414

1.41421

1.4142136

1.41421356

1.414213562

ще отбележим, че при извеждането на числа с плаваща точка се извършва закръгляне; ако използваме манипулатора setprecision тялото на цикъла трябва да изглежда така:

cout << setprecision (i) << root2 << endl;

#include

void main ()

{ int w = 4;

char string[10];

cout << “Въведете изречение: “; cin.width (5);

while (cin >> string)

{ cout.width (w++);

cout << string << endl;

cin.width (5);

}

}

ако въведем изречението: Това е проверка. програмата ще върне

потребителите могат да създават свои собствени манипулатори на потоци, включително и параметризирани; пример:

#include

ostream &bell (ostream &output)

{ return output << ‘\a’; } //извеждане на звук

ostream &ret (ostream &output)

{ return output << ‘\r’; } //връщане в началото на реда

ostream &tab (ostream &output)

{ return output << ‘\t’; } //отместване с 8 символа

ostream &endline (ostream &output)

{ return output << ‘\n’ << flush; } //аналогичен манипулатор на endl

void main ()

{ cout << endline << ‘a’ << tab << ‘b’ << tab << ‘c’ << endline

<< “!!!!!”;

for (int i = 1; i <= 10; i++) cout << bell;

cout << ret << “______” << endline;

}

програмата връща:

______

състоянието на формата се определя от защитената данна елемент

x_flags от тип long в класа ios; всеки флаг представлява отделен бит в x_flags – той има стойност 1, ако е вдигнат и 0 в противен случай;

за обединяване на няколко флага в една стойност от тип long може да се използва операцията поразрядно логическо или (‘|’);

извикването на функцията елемент flags с един параметър от тип long задава нова стойност за променливата x_flags, т.е. задава нови стойности за всички флагове за състоянието на формата, и връща нейната предишна стойност; ако функцията бъде извикана без параметри, тя само връща текущата стойност на x_flags;

например след извикването:

cout.flags (ios::fixed | ios::showpoint)

флаговете fixed и showpoint ще бъдат вдигнати (ще имат стойност 1), а всички останали флагове ще имат стойност 0;

функцията елемент setf има два варианта:

long setf (long setbits, long resetbits);

този вариант анулира битовете resetbits в променливата x_flags и включва битовете setbits;

long setf (long setbits);

този вариант включва битовете setbits в променливата x_flags;

извикванията cout.flags (cout.flags() | setbits) и cout.setf (setbits) са еквивалентни;
параметризираните манипулатори setiosflags и resetiosflags изпълняват същите действия както функциите setf и unsetf съответно;
вдигнатият флаг skipws показва, че операцията въвеждане от поток (>>) трябва да пропуска символите разделители (‘ ‘, ‘\n’, ‘\t’); по премълчаване skipws е вдигнат, т.е. разделителите се пропускат; ако флагът skipws е вдигнат, то с помощта на извикванeто

cin.unsetf (ios::skipws) се отменя пропускането на разделителните символи; манипулаторът ws вдига флага skipws;

cout << 9.9900 << endl

cout.setf (ios::showpoint);

cout << 9.9900 << endl

<< 9.9000 << endl

<< 9.0000 << endl;

този фрагмент ще изведе:

9.99

9.9

9.990000

9.000000
флаговете left и right задават подравняване на изведеното съответно отляво и отдясно на полето; празните позиции се заемат от запълващия символ (по подразбиране ‘ ‘); по премълчаване подравняването е отдясно;

пример:

int x = 12345;

cout.setf (ios::left, ios::adjustfield);

cout << x << endl;

cout.unsetf (ios::left);

cout << setw (10) << x << endl << setw (10)

<< setiosflags (ios::left) << x << endl

<< setw (10) << resetiosflags (ios::left)

<< x << endl;

фрагментът ще изведе:

_ _ _ _ _ 12345

12345 _ _ _ _ _

_ _ _ _ _ 12345

12345 _ _ _ _ _

_ _ _ _ _ 12345
аргументът ios::adjustfield, който съдържа трите флага left, right, internal е необходимо да се задава като параметър на функцията setf, когато тя се използва за вдигане на тези флаговете, тъй като чрез него първоначално те се изчистват, което гарантира, че след изпълнението на setf точно един от трите флага е вдигнат – това се налага, тъй като те взаимно се изключват;
вдигнатият флаг internal показва, че знакът на числото или основата при вдигнат флаг showbase трябва да се подравнява отляво, стойността на числото да се подравнява отдясно, а в междинните позиции да се вмъкнат запълващи символи; вдигането на флага showpos води до извеждане на ‘+’ за положителни числа; пример:

cout << setiosflags (ios::internal | ios::showpos)

int x = 10000;

cout.setf (ios::showbase);

cout << setw (10) << x << endl;

cout.setf (ios::left, ios::adjustfield);

cout << setw (10) << x << endl;

cout.setf (ios::internal, ios::adjustfield);

cout << setw (10) << hex << x << endl;

cout.setf (ios::right, ios::adjustfield);

cout.fill (‘*’);

cout << setw (10) << dec << x << endl;

cout.setf (ios::left, ios::adjustfield);

cout << setw (10) << setfill (‘%’) << x << endl;

cout.setf (ios::internal, ios::adjustfield);

cout << setw (10) << setfill (‘*’) << hex << x << endl;

фрагментът ще изведе:

функцията елемент fill задава запълващ символ и връща предишния такъв; манипулаторът setfill има същото действие;

ios::basefield; ако нито един от флаговете не е вдигнат, то по премълчаване целите числа при операция извеждане в поток се интерпретират като десетични; при операцията въвеждане от поток данните по премълчаване се обработват в тази форма, в която се посочват – целите започващи с 0 като осмични, започващи с 0x или 0X като шестнайсетични, а всички останали като десетични;

ако за потока е зададена основата, то всички цели числа в този поток се обработват при тази основа, докато не бъде зададена нова основа;

при вдигнат флаг showbase се извежда основата на целите числа – осмичните започват с 0, шестнайсетичните с 0X или 0x; пример:

int x = 100;

cout << setiosflags (ios::showbase) << x << endl

фрагментът извежда:

100

0144

double x = .001234567, y = 1.946e09;

cout << x <<’\t’ << y << endl;

cout.setf (ios::scientific, ios::floatfield);

cout << x << ‘\t’ << y << endl;

cout.unsetf (ios::scientific);

cout << x << ‘\t’ << y << endl;

cout.setf (ios::fixed, ios::floatfield);

cout << x << ‘\t’ << y << endl;

фрагментът извежда:

0.001235 1.946e+09

1.234567e-03 1.946000e+09

0.001235 1.946e+09

0.001235 1946000000.000000

cout << setiosflags (ios::uppercase) << hex << 123456789 << endl;

cout << setiosflags (ios::showbase) << hex << 123456789 << endl;

фрагментът извежда:

75BCD15

0X75BCD15

битът eofbit за входен поток автоматично се включва, ако се срещне признак за край на файла; потребителят може да използва функцията елемент eof за да определи стойността на бита – тя връща стойност истина, ако eofbit е включен и лъжа в противен случай;

битът failbit се включва, ако в потока възникне грешка при форматирането, но символи не се губят; обикновено след тази грешка данните могат да се възстановят; функцията елемент fail, аналогично на eof може да се използва за да се определи дали failbit е включен;

битът badbit се включва при възникване на грешка, която води до загуба на данни; обикновено след такава грешка данните не могат да се възстановят; функцията елемент bad може да се използва за проверка на стойността на badbit;

битът goodbit се включва, ако нито един от битовете eofbit, failbit, badbit не е включен, т.е. ако не са възникнали грешки; функцията елемент good връща истина, ако goodbit е включен и лъжа в противен случай;
функцията елемент rdstate връща стойността на защитения елемент state, който съдържа стойностите на всички битове, определящи състоянието на потока; върнатата стойност евентуално може да се използва за проверка на битовете eofbit, failbit, badbit, goodbit, но

по-удобно средство е използването на функциите елементи

eof, fail, bad, good;
функцията елемент clear променя стойността на защитения елемент state от класа ios, в който са записани битовете за състоянието на потока; обикновено тя се използва за възстановяване на потока в нормално състояние, т.е. тя изключва битовете eofbit, failbit, badbit и включва бита goodbit; функцията има един параметър, който по премълчаване има стойност goodbit, така че например извикването

cin.clear () изчиства състоянието на входния поток cin и включва бита goodbit; оператора cin.clear (ios::failbit) включва бита failbit (и изключва всички останали битове) и той може да се използва ако програмистът срещне проблем при обработката на потребителски тип от данни със cin; пример:

int x;

cout << cin.rdstate () << ‘ ‘

cin >> x; //въвеждаме символ

cout << cin.rdstate () << ‘ ‘

<< cin.eof () << ‘ ‘

<< cin.fail () << ‘ ‘

<< cin.bad () << ‘ ‘

<< cin.good () << endl;

cin.clear ();

cout << cin.rdstate () << ‘ ‘

<< cin.eof () << ‘ ‘

<< cin.fail () << ‘ ‘

<< cin.bad () << ‘ ‘

<< cin.good () << endl;

фрагментът връща:

0 0 0 0 1

2 0 2 0 0

0 0 0 0 1
6. Пространства от имена.
една програма включва много идентификатори, които са с различна област на действие; понякога идентификатор от една област на действие може да бъде дублиран с идентификатор със същото име от друга област на действие; дублирането на идентификатори често възниква в библиотеки от независими разработчици, в които се използват едни и същи имена за външни (глобални) идентификатори;

в такива случаи обикновено се генерира грешка по време на компилация;

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

възможно е да се избегне посочването на името на пространството при използването на даден елемент; това се постига чрез оператор

using име_на_пространство::елемент_на_пространство,

поставен в началото на блока, в който този елемент се използва;
оператора

using namespace име_на_пространство;

поставен в началото на блок указва, че всички елементи от това пространство от имена могат да се използват в блока без да се задава името на пространството;
в стандарта на ANSI C++ дефинициите на всички класове, обекти и функции в стандартната библиотека на C++ се намират в пространството от имена std, така че в програмите, които са съобразени с този стандарт трябва да се поставя std:: пред всички стандартни класове, обекти, функции и т.н.; друг начин е използването на оператор

using namespace std;

в началото на програмата; това, обаче, се смята за лоша практика, тъй като употребата на този оператор е смислена само ако членовете на това пространство ще се използват често; препоръчва се чрез другата форма на using да се укажат само тези идентификатори, които ще се използват – например:

using std::cout; using std::endl;

в стандарта на ANSI C++ заглавните файлове нямат разширение ‘.h’;

пример (за стандарта на ANSI C++):

#include

using namespace std;

int myint = 98;

namespace Example {

const double PI = 3.14159;

const double E = 2.71828;

int myint = 8;

void printvalues ();

namespace Inner {

enum years { FISC1 = 1990; FISC2; FISC3 } ;

}

}

namespace {

}

void main ()

cout << “Глобален myint = “ << myint << endl;

cout << “PI = “ << Example::PI << endl;

cout << “E = “ << Example::E << endl;

cout << “Example myint = “ << Example::myint << endl;

cout << “FISC3 = “ << Example::Inner::FISC3 << endl;

Example::printvalues ();

}

void Example::printvalues ()

cout << “myint = “ << myint << endl;

cout << “PI = “ << PI << endl;

cout << “E = “ << E << endl;

cout << “d = “ << d << endl;

cout << “Глобален myint = “ << ::myint << endl;

cout << “FISC3 = “ << Inner::FISC3 << endl;

}
при определяне на пространство от имена се използва следния синтаксис:

namespace име_на_пространство

{ идентификатори }

за разлика от тялото на класа и структурата, тялото на пространството не завършва с ‘;’ ; елементът myint от пространството

Example има същото име като външната променлива myint, но това не води до синтактична грешка, тъй като двете променливи са в различни пространства от имена; при описанието на функцията printvalues, елементите на пространството Example са достъпни непосредствено, тъй като самата функция е от това пространство;

пространствата от имена могат да съдържат константи, променливи, функции, класове, дори вложени пространства; дефинирането на пространства от имена трябва задължително да става в глобалната област на действие или да бъде вложено в друго пространство;

елементите на пространството без име са част от глобалното пространство от имена – те са достъпни непосредствено; външните променливи също са част от това пространство; всички елементи на глобалното пространство от имена са достъпни във всички области на действие, разположени след тяхното дефиниране; при дублиране на вътрешни идентификатори с идентификатори от глобалното пространство може да се използва унарната операция за разрешаване на област на действие; за разлика от външните променливи, елементите които са дефинирани в тялото на пространството без име не са достъпни за други първични файлове, т.е. пространството без име заменя спецификатора static за връзка между първичните файлове;

namespace ново_име_на_пространство = старо_име_на_пространство

друго предимство на новите операции за преобразуване е, че те имат съвършено различно предназначение за разлика от старото преобразуване, което се използва във всички случаи;

с нея се извършват стандартни преобразувания – например

void* в char*, int в double и т.н., както и обратните им преобразувания; синтаксисът на операцията е:

static_cast <нов_тип> (израз)

извършването на неразрешено преобразуване с помощта на static_cast води до синтактична грешка;

примери за неразрешено преобразуване са:

• 
  преобразуване на константни в неконстантни типове и обратно;
  
• 
  преобразуване на типове на указатели и псевдоними в типове, които не са в отношение на открито наследяване;
  
• 
  преобразуване към тип, за който няма съответен конструктор или операция за преобразуване;
  

#include

using std::cout;

using std::endl;

class BaseClass {

public:

{ cout << “Base” << endl; }

} ;

class DerivedClass : public BaseClass {

void f () const

{ cout << “Derived” << endl; }

} ;

void main ()

{ double d = 8.22;

int x = static_cast < int > (d);

cout << “d = “ << d << endl

<< “x = “ << x << endl;

BaseClass *basePtr = new DerivedClass;

test (basePtr);

delete basePtr;

}
void test (BaseClass *basePtr)

{ DerivedClass *derivedPtr;

derivedPtr = static_cast (basePtr);

derivedPtr -> f ();

}
операцията const_cast премахва или добавя спецификаторите

const и volatile чрез преобразуване; спецификаторът за тип volatile се използва, когато достъпът до обектите от този тип ще се осъществява по-начин, който не може да бъде предвиден от компилатора; той се използва за подтискане на различни видове оптимизации; синтаксисът на операцията const_cast е:

const_cast <нов_тип> (израз)

ще отбележим, че операцията const_cast не може директно да премахне спецификаторите const и volatile от тип на променлива – тя прави това само в рамките на конкретния израз; пример: