CITB308 Структури от данни



1. Език за програмиране С++

Основни елементи на C++
Изрази
Управляващи оператори
Функции
Класове

Основни елементи на C++

Проста С++ програма

#include <stdlib>
#include <iostream>
int main()
{ int x, y;
  std::cout << "Please enter two numbers: ";
  std::cin >> x >> y; // input stream
  int sum = x + y;
  std::cout << "Their sum is " << sum << std::endl;
return EXIT_SUCCESS;
}

Елементи

-- оператор (statement) - част от програма (завършва с ;)
-- операция (operator) - елемент на езика (+, =, ==)
-- операция (operation)  - като действие или състояние (събиране, присвояване, равно)

Основни типове данни
bool
char
short
int
long
float
double
enum
boolean
character
integer
integer
long integer
single-precision floating point
double-precision floating point
enumeration
true, false
писмен знак, символ - 'A'
къс цял
цял
дълъг цял
единична точност плаваща запетая
двойна точност плаваща запетая
изброяване - множество от отделни стойности

bool, char, int и enum се наричат интегрални типове (integral types).
void показва липса на всякаква информация за типа (само за тип на функция).

Изброен тип
Изброяване (enumeration) е дефиниран от потребителя тип, който съдържа отделни стойности.
enum Color { RED, GREEN, BLUE };  // default values are 0, 1, 2
enum Week { MONDAY = 1, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY};
// values are 1, 2, 3, .., 7
enum Mood { HAPPY = 3, SAD = 1, ANXIOUS = 4, SLEEPY = 2 };
Color skyColor = BLUE;
Mood myMood = SLEEPY;
Week day = TUESDAY;
Указатели (pointers)
Всяка променлива се съхранява в паметта на компютъра на някакво място, наречено адрес. Указателят съдържа този адрес (число).
Стойността на операция адрес (&) е адресът на обекта (променливата), единствен аргумент на тази операция.
Достъп до обекта, адресиран от указателя се осъществява с операция стойност на указател (dereferencing), която се означава със  *.
char ch = 'Q';  
char* p = &ch; // p holds the address of ch
cout << *p; // outputs the character 'Q'
ch = 'Z'; // ch now holds 'Z'
cout << *p; // outputs the character 'Z'

Масиви (arrays)
Масив е множество (редица) от елементи от едни и същи тип.
double f[3];    // array of 3 doubles f[0], f[1], f[2]
double* p[10]; // array of 10 double pointers p[0]..p[9]
f[2] = 2.5;
p[4] = &f[2]; // p[4] points to f[2]
cout << *p[4]; // outputs 2.5
int a[] = { 10, 11, 12, 13 }; // initialization
int b[20] = { 0 }; // initialize all elements with value 0
C++ не поддържа проверка за излизане на индексите извън границите на масива [common programming error]!

C-структури (structures)
Структурата съхранява съвкупност от елементи. Елементите (членове или полета) могат да бъдат от различни типове.

enum MealType { NO_PREF, REGULAR, LOW_FAT, VEGETARIAN };
struct Passenger {
string name; // "John Smith"
MealType mealPref; // LOW_FAT
bool isFreqFlyer; // true
string freqFlyerNo; // "293145"
};

Дефинира се нов тип Passenger. Достъп до член на структурата се дава с операция "точка": struct_variable.member.
	
Passenger pass = { "John Smith",
LOW_FAT, true, "293145" };
pass.name = "Pocahontas"; // change name
pass.mealPref = VEGETARIAN; // change meal preference

Това е C-структура. Като цяло, структури и класове в C++ предоставят много по-широка гама от възможности, отколкото това, което е възможно в C-структурите (член функции, контрол на достъпа и др.).

Динамична памет, операция new
C++ системата за изпълнение на задания (runtime system) запазва блок от паметта на компютъра, наречена динамична памет (free memory, dynamic memory or heap memory).
Операция new динамично отделя точното количество памет за обект от даден тип и връща адреса на обекта.

Passenger *p;
//...
p = new Passenger; // p points the new Passenger
p->name = "Pocahontas"; // member selection(arrow) operator
p->mealPref = VEGETARIAN; // change meal preference
p->isFreqFlyer = false;
p->freqFlyerNo = "NONE";
//...
delete p;

Новият обект от тип  Passenger съществува в динамичната памет докато не бъде изтрит.

Memory Leaks
Ако обектът е създаден с операция new, то той трябва да се изтрие (да се освободи заеманата динамична памет) с delete.
char* buffer = new char[500];
//...
delete buffer; // ERROR: delete only the fist element buffer[0]
Оставяне на недостъпни обекти в динамичната памет се нарича "изтичане на памет" (memory leak).
char* buffer = new char[500];
//...
delete [] buffer; // delete all elements
Константи и typedef
const double PI = 3.14159265;
const int CUT_OFF[] = {90, 80, 70, 60}
;
const int N_DAYS = 7;
const int N_HOURS = 24*N_DAYS;
int counter[N_HOURS];
Често е полезно да се асоциира ново име с някой (обикновено съставен) тип:
typedef char* BufferPtr;   // type BufferPtr is a pointer to char
typedef double Coordinate
; // type Coordinate is a double
//...
BufferPtr p; // p is a pointer to a char
Coordinate x, y; // x and y are of type double

Локален и глобален обхват (видимост, scope)
Частта от програмата, където дадено име е достъпно се наричат ​​негов обхват.
const int cat = 1;      // global cat
int main()

{
const int
cat = 2; // local cat (to main)
cout << cat; // outputs 2
return 0;
}
int dog = cat; // dog = 1 (from global cat)

Пространства от имена (namespaces)
Именното пространство е механизъм, който позволява на група от свързани имена да бъдат дефинирани на едно място.
namespace myglobals {
int cat;

string dog = "bow wow";
}

int d = myglobals::cat;
  Достъп до обект x в именното пространство group дава операция "принадлежност" :: (scope):  group::x.
namespace.cpp

  Оператор using
using std::cout;
using myglobals::cat;
или
using namespace std;
using namespace myglobals;

Изрази

Изразът съчетава променливи и литерали с операции за създаване на нови стойности.

Избиране на член (member selection) и индекс

Нека:
Операции (lvalue):
class_name.member class/structure member selection
dot (member selection) operator операция "точка"
pointer->member
class/structure member selection arrow operator
операция "стрелка"
array[exp]
array subscripting
index (subscript) operator
операция "индекс"

Аритметични операции

Бинарни аритметични операции (rvalue):
exp + exp
addition
събиране
exp - exp subtraction
изваждане
exp * exp multiplication
умножение
exp / exp division
деление
exp % exp modulo (remainder)
остатък

Унарни операции: +x и -x.

Операции увеличаване (increment) и намаляване (decrement)
var++
post increment
var--
post decrement
++var pre increment
--var pre decrement

int a[] = { 0, 1, 2, 3 };
int i = 2;
int j = i++; // j = 2 and then i = 3
int k = --i; // i = 2 and then k = 2
cout << a[k++]; // a[2] (=2) is output; then k = 3
Операции за сравнение:
exp < exp
less than
по-малко
exp > exp greater than
по-голямо
exp <= exp less than or equal to
по-малко или равно
exp >= exp greater than or equal to по-голямо или равно
exp == exp equal to
равно
exp != exp not equal to
неравно
Стойности на тези операции са логическите стойности - true и false.

Логически операции:
! exp
logical not логическо "не"
exp && exp logical and логическо "и"
exp || exp logical or логическо "или"
exp може да бъде логически или аритметичен израз (0 означава false, ненула означава true).

Побитови операции:
~exp
bitwise complement, ex.
~100010 -> 011101 побитово отрицание
exp & exp bitwise and (conjunction), ex.
1001 & 1100 -> 1000 побитово "и"
exp ^ exp bitwise exclusive-or
1001 ^ 1100 -> 0101
побитово изключващо "или"
exp | exp bitwise or (disjunction)
1001 | 1100 -> 1101
побитово "или"
exp << exp shift left 11001 << 1  -> 10010
преместване наляво
exp >> exp shift right
11001 >> 1 -> 01100
преместване надясно

Операции за присвояване
Аритметичните операции (+, -, *,  /, % ) и побитовите бинарни операции (&, ^, |, <<, >>) се комбинират с оператора за присвояване =.
int i = 10; 
int j = 5;
int k = 1;
i -= 4; // i = i - 4; result 6

j *= -2; // j = j * (-2); result -10
k <<= 1; // k = k << 1; result 2

Други операции
class_name :: member
class scope resolution
принадлежност към клас
namespace_name :: member namespace scope resolution принадлежност към именно пространство
exp ? exp : exp
conditional expression
условна операция
stream >> var
input stream (overloaded)
входен поток
stream << exp
output stream (overloaded)
изходен поток

Приоритет на операциите
Операциите в C + + имат приоритет, който определя реда, по който операциите се извършват при липса на скоби.
Operator Description Associativity
:: scope Left
() [ ] -> . sizeof   Left
++ -- increment, decrement Right
~ bitwise complement
! (not)
unary NOT
& * reference and dereference
..._cast, (type)
type casting
+ - unary + and -
* / % arithmetic operators Left
+ - addition, subtraction Left
<< >> bitwise shifts
Left
< <= > >= relational operators Left
== != relational operators Left
&
bitwise and
Left
^ bitwise exclusive-or Left
| bitwise or
Left
&& (and)
logical operator and
Left
|| (or)
logical operator or
Left
?: conditional operator
Left
= += -= *= /= %=
>>= <<= &= ^= |=
assignment operators
Right
, comma, separator Left

int a = 10, b, c, d;  
// right associativity
d = c = b = a; // is equivalent to d = (c = (b = a));
// left associativity
d - c + b - a; // is equivalent to ((d - c) + b) - a;
// precedence
d > c && -b <= a // is equivalent to (d > c) && ((-b) <= a)


Управляващи оператори

if (<condition>) <operator>;
if (<condition>) <operator1>; else <operator2>;
while(<condition>) <opetator>;
do <operator>; while(<condition>);
for ([<initialization>]; [<condition>]; [<increment>]) <operator>;
for ([<expression1>]; [<expression2>]; [<expression3>]) <operator>;
return [<expression>];


Функции

Предефиниране (overloading) на функции
Предефиниране на функции имаме, когато две или повече функции са дефинирани със същото име, но различни списъци от параметри.
void print(int x)
{ cout << x; }
	
void
print(const Passenger &pass)
{
cout << pass.name << " " << pass.mealPref;
if (pass.isFreqFlyer) cout << pass.freqFlyerNo;
}

Предефиниране на операции
Тест за равенство за два Passenger обекти:
bool operator==(const Passenger &x, const Passenger &y)
{
return x.name == y.name &&
x.mealPref == y.mealPref &&
x.isFreqFlyer == y.isFreqFlyer &&
x.freqFlyerNo == y.freqFlyerNo;
}


Използване на предефинирането
	
ostream& operator<<(ostream &out, const Passenger &pass)
{
out << pass.name << " "
<< pass.mealPref;
if (pass.isFreqFlyer) out << pass.freqFlyerNo;

return out;
}
//...
Passenger pass1 = // details omitted
Passenger pass2 = // details omitted
cout << pass1 << pass2 << endl;


Класове

Структура на класа
Класът се състои от членове. Членове, които са променливи или константи са данни (член-променливи) и членове, които са ​​функции се наричат член-функции (методи).

Достъп
Членовете могат да бъдат обявени за публични (public) и те са достъпни за функции извън класа или частни (private), които са достъпни само за функциите от този клас. По подразбиране всички членове са частни.

Член-функции
enum MealType { NO_PREF, REGULAR, LOW_FAT, VEGETARIAN };
class Passenger {
private:
string name; // "John Smith"
MealType mealPref; // LOW_FAT
bool isFreqFlyer; // true
string freqFlyerNo; // "293145"
public:
Passenger(); // default constructor
bool isFreqFlyer() const; // accessor function
void makeFreqFlyer(const string &newFreqFlyerNo);
// update (mutator) function
};
// ...
bool Passenger::isFreqFlyer() const
{
return
isFreqFlyer;
}
void Passenger::makeFreqFlyer(const string &newFreqFlyerNo)
{
isFreqFlyer = true;
freqFlyerNo = newFreqFlyerNo;
}
//...
Passenger pass;
//...
if (!pass.isFreqFlyer()) // OK
pass.makeFreqFlyer("999999"); // OK
pass.name = "Joe Blow"; // ERROR: private member

Дефиниции на функции в класа (in-class)
	enum MealType { NO_PREF, REGULAR, LOW_FAT, VEGETARIAN };
class Passenger {
private:
string name; // "John Smith"
MealType mealPref; // LOW_FAT
bool isFreqFlyer; // true
string freqFlyerNo; // "293145"
public:
Passenger();
bool isFreqFlyer() const
{ return isFreqFlyer; }  
void makeFreqFlyer(const string &newFreqFlyerNo)
{
isFreqFlyer = true;
freqFlyerNo = newFreqFlyerNo;
}
};

Приятелски класове
class Matrix;              // Matrix definition comes later
class Vector {             // a 3-element vector
private:
  double coord[3];
public:
  // ...
  friend class Matrix;     // allow Matrix access to coord
};
class Matrix {             // a 3x3 array
private:
  double a[3][3];
public:
  // ...
  Vector multiplyBy(const Vector& v) {  // multiply (a * v)
    Vector w(0, 0, 0);
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        w.coord[i] += a[i][j] * v.coord[j]; // access private data
    return w;
  }
};

Вложени класове
Класовете може да съдържат променливи, член-функции и типове. Може да се влагат и дефиниции други класове.
class Complex {
private:
class Node {
// ...
};
//...
};

Стандартна библиотека с шаблони (STL)
Стандартната библиотека с шаблони (Standard Template Library - STL) е колекция от полезни класове за общи структури от данни.

Стандартни контейнери:

stack
Container with last-in, first-out access
стек
Контейнер с достъп LIFO
queue
Container with first-in, first-out access опашка
Контейнер с достъп FIFO
deque
Double-ended queue
дек
Опашка с два края
vector
Resizeable array
вектор
Масив с променлива дължина
list
Doubly linked list

Двусвързан списък
priority_queue
Queue ordered by value

Приоритетна опашка
set, multiset
Set
множество

map, multimap
Associative array (dictionary)

Асоциативен масив (речник)

  Всеки STL-клас може да съдържа обекти от произволен тип.
vector<int> scores(100);  
vector<char> buffer(500);
vector<Passenger> passList(20);
vector<int> newScores = scores;
vector.cpp