Презентация на тему Программирование II

языка C++)
Объектно-ориентированное проектирование.
Модели данных и базы данных (на примере

Конструкторы/деструкторы.
Статические члены и методы.
Перегрузка имен. Переопределение операторов.
Друзья класса.
Области видимости

с англ. – М: М: ДМК Пресс; СПб: Питер,

{
st->sp=0;
st->sz=size;
st->bf=(int*)malloc(size*sizeof(int));
}

void deinit_stack(Stack* st) {
free(st->bf);
}

int empty(Stack*

#include "myStack.h"

void main()
{
Stack st;
init_stack(&st,100);
push(&st,5);
. . .
while (! empty(&st))
{
int x=pop(&st);
. . .
push(&st,x*x);
. . .
}
deinit_stack(&st);
}

файл myStack.c

файл prog.c

typedef struct {
int sz;
int sp;
int* bf;
} Stack;

void init_stack(Stack*, int);
void deinit_stack(Stack*);

int empty(Stack*);
void push(Stack*,int);
int pop(Stack*);

файл myStack.h

языка
Удобное моделирование математических концепций (в С пользовательские типы не

ISO стандарт – 1990 год).
Начало 80-х – С

поразумевает int.
Устаревшее описание параметров функций и процедур.
В С++ появились

приведении типов, параметры по умолчанию, операторы распределения динамической памяти.

bool: true/false
int y=int(b);//у имеет значение 0
x=int(y == 0);//x имеет

PI = 3.14159;
const int v[]={1,2,3}; //массив констант


void f(const

* q)
{
char s[]=“abc”;

const char * pc=s;

в C++
void Inc(int& x)
{
x++;
}
…
Inc(y);
…

//уточнение в С++
void Inc(int * const x)
{
(*x)++;
}
…
Inc(&y);
…

{
double re;
double im;
} _Complex;
class Complex {
private:
double re;
double im;
public:
};

class _Complex {
public:
double re;
double im;
};

_Complex s; s.re+=s.im; //правильно: оба члена открыты

Complex c; c.re+=c.im; //ошибка: члены класса закрыты

sz;
int sp;
int* bf;
public:
//объединяет варианты Stack() и Stack(int)
Stack(int=100);

#include “Stack.h”

void main()
{
Stack st100, st(5000);
…
st100.push(123);
…
while (!st100.empty()) {
… st.push(st100.pop());
…
}
}

в блок.
Создание объекта в динамической памяти: Stack* st100=new Stack(); Stack* st=new

stk; //создается при запуске программы до вызова main int main()

класса: class newClass { Stack stk; int num; public:

умолчанию.
Конструктор, для всех аргументов которого заданы умолчательные значения,

же самого типа, называется копирующим конструктором. //ВАЖНО: параметр – ссылка,

100
sp 0
bf
s1


sz

s2

Вах!!!

управление выходит из блока, где они описаны;
– для статических

int BOUND=100;//статич. константа интегрального типа
static int

this->

{ /*инициализация других членов*/ }
~SomeClass() {
delete[] cache;

следующие случаи:
имя массива и указатель void print(char*); … char a[]=“abc”; print(a);
имя

Процедура поиска (процедура разрешения неоднозначности) соответствия вызова определению функции основывается на проверке набора критериев в следующем порядке:

продвижения в «охватывающие» типы:
bool, (signed/unsigned) char, short -> int
float

зависит от порядка объявления функций.
Тип возвращаемого значения не используется

r=0.0, double i=0.0) : re(r), im(i) {}
Complex operator+(Complex x)

* / %

виде нестатической функции-члена с одним аргументом: class X { … public: X(int); void operator+(int); … }
Либо

виде нестатической функции-члена : class X { … public: void operator~();

работает с уже существующим
объектом:

class Stack{
int sp;
int

100
sp 0
bf
s1


sz

s2

Вах!!!

s2=s1;

...

Вах!!!

cout, cerr;

istream& operator>>(istream&, int);
ostream& operator

r=0.0,double i=0.0) : re(r), im(i) {}
double real() const {

по линейной алгебре: … while (…) {… Z=M*X+Y; …} … где

Matrix&,

mvv) { mul_add_and_assign(this,&mvv.m,&mvv.v,&mvv.v2);
return *this; }
};
…
Matrix M;
Vector X,Y,Z;
…
Z=M*X+Y;
…
Z.operator=(MVmulVadd(MVmul(M,X),Y));
mul_add_and_assign(&Z,&M,&X,&Y);
Z=M*X+Y и отложенные вычисления –

закрытой части класса;
находится в области видимости класса;
вызывается для объекта

Vector operator*(const Matrix&, const Vector&);
…
}

class Matrix {
int numRows, numColumns;
…
friend

private-, так и в
public-части описания класса.
Отношение «дружбы» не

всей программы).
Локальная ОВ (внутри блока).
ОВ класса.
ОВ пространства имен.

namespace UsefulThings

всех описаний из пространства имен:

using namespace UsefulThings;
…
Stack sp=Stack(10);

«Глобализация» одного

int Var; }
int Var;
void main() {
using namespace ZZZ;
Var++;

Var++; … //находится в той же единице трансляции, что

месте их возникновения, нужно:
сгенерировать информацию об ошибке;
перехватить эту информацию

n=0) : limit(n) {}
char* Message() { return /*выдать информацию

здесь, если:
//1. H того же типа, что и E.
//2.

E();
}
catch (...) {
if (...)
//внештатная ситуация может

LA=LexicalAnalyser;
…
while (true)
try {
LA::Lexer(inputStream); //чтение и разбор входного потока
}
catch (LA::Number&

stdlib.h
void* Base,

используем многократно; в качестве параметров выступают конкретные значения, типы

int r) {
if (p < r)

sz;
int sp;
Type bf[size];
public:
Stack() : sp(0), sz(size)

#include “Stack.h”

сlass SomeClass {
//нужно что-нибудь?
} var;

void main()
{
Stack intStack;
Stack st[10];
…
intStack.push(123);
st.push(var);
while (!st.empty()) {
…
st.push(*new SomeClass());
…
}
…
}

sz;
int sp;
Type *bf;
public:
Stack(int=100);
~Stack() {
delete [] bf;
}
bool empty() const

Stack {
int sz, sp;
Type

const { return val; }
};

template void proc(Stack&

Type> class Stack {
public:
class Stack_Overflow {};
class Stack_Underflow {};
virtual bool

типов в C
typedef struct {
Common com;
int radius;
}

typedef struct {
Common com;
Point* vectors;
} Polygon;

typedef struct {
int x;
int y;
} Point;
typedef int Color;
typedef enum { circ, poly } Kind;
typedef struct {
Kind kind;
Point startpoint;
Color color;
Color bordercolor;
} Common;

typedef union {
Circle circle;
Polygon polygon;
} Shape;

void RotatePolygon(Polygon p, int angle)
{ /*...*/ }

void Rotate(Shape* s, int angle)
{
switch (s->circle.com.kind)
{
case circ:
//вращать не надо!!!
return;
case poly:
RotatePolygon(*s,angle);
return;
default:
//ошибка!!!
}
}

void RotateAll(Shape* figs,int n,int a)
{
for(int i=0; i rotate(figs+i,10);
}

{
Shape common;
Point* vectors;
} Polygon;

Point where(struct Polygon s) {

typedef struct {
Shape common;
int radius;
} Circle;

Point where(struct Circle s) {
return s.common.startpoint;
}
void draw(struct Circle s) {
//...
}
void rotate(struct Circle s, int angle){}

typedef struct {
Point startpoint;
Color color;
Color bordercolor;
} Shape;
Point Where(struct Shape s) { return s.startpoint; }
void Draw(struct Shape s) { ??? }
void Rotate(struct Shape s, int angle) { ??? }

множества других
классов, называется полиморфным типом.

class Shape {
Point

Manager : public Person {
list staff;
Date

void proc(Manager m, Person p) { Person* pp=&m;
Manager* pm=&p;
//…=static_cast(&p);

pm->level=2; //!!!
pm=static_cast(pp);
pm->level=2;

p=m; //!!!
m=p;

m.staff.push_front(&m);
m.staff.push_front(&p);
}

Person p;

Manager m;

int* x=reinterpret_cast(0xEEEE);
dynamic_cast void proc(Base* pb) {

stack, map, multimap, set, multiset, bitset;
memory (распределение памяти);
iterator (стандартные

class stack {
Container c;
public:
typedef _Container container_type;
typedef typename Container::value_type value_type;
typedef

for_each(_InIt _First, _InIt _Last, _Fn1_Func) {
for (; _ChkFirst

– C++/CLI

C++ компании Микрософт появились в 2002 в связи с

ссылками на них, а также освобождение объектов, когда они

резервирует для него непрерывную область адресного пространства – управляемую

выполняет сборку мусора, он освобождает память, выделенную для объектов,

части управляемой кучи быстрее, чем для всей кучи.
Более

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

управляемые к/с.
gcnew – выделение памяти в управляемой куче.
nullptr –

могут создаваться в разделах памяти разных типов (например, стек

указателя на члены объекта управляемого типа (внутрь и только

указателя, который предотвращает перемещение СМ объекта, внутрь которого он