Размещено на http://allbest.ru/

Нижегородский Государственный Технический Университет

Кафедра ИСУ

Контрольная работа

по дисциплине: «Технология программирования»

Новгород

Данная программа осуществляет игру по 2-м уровням сложности, для игры полей. Предусматривается возможность отката назад на несколько ходов. Поиск хода осуществляется компьютером с помощью б-в процедуры.

Правила игры

Правила игры в шашки достаточно просты и понятны. Существует клетчатая доска, похожая на шахматную, с белыми (светлыми) и чёрными (тёмными) клетками. Шашки обоих соперников располагаются в несколько рядов, начиная от края доски, на тёмных клетках. Первыми ходят белые. Шашки ходят только по диагонали и, соответственно могут передвигаться только по чёрным квадратам доски. Ходить обычные шашки могут только вперёд. Исключение здесь составляют лишь возможность бить шашки противника назад в некоторых разновидностях правил игры. Бить шашку соперника означает "перепрыгнуть" через неё по диагонали. В этом случае бившая шашка становится за битой, которая в свою очередь снимается с доски. Шашка, достигшая противоположного края доски, превращается в дамку. Дамка может перемещаться как вперёд, так и назад. Цель игры - заблокировать или убрать с доски все шашки противника.

Несмотря на простоту правил, существует масса разновидностей этой игры в мире. Все схожие правила шашек указаны выше. Далее начинаются хоть и местами незначительные, но различия.

Поддавки. Шашки в привычном для нас понимании.

· Доска: 8х8 (как в шахматах);

· Количество шашек у игрока: 12;

· Расположение: первые 3 ряда;

· Бить: произвольное количество шашек в любом направлении;

· Бить назад: разрешено;

· Дамка: передвигается на любое количество полей; если шашка била через поле превращения, она всё равно становится дамкой;

Правила соответствуют русским шашкам. Бить шашки обязательно. Цель игры - как можно быстрее снять с доски все свои шашки. Выигрывает тот, кто первым остался без фигур.

Инструкция пользователя

Для начала игры необходимо выбрать пункт File\level_(выбрать уровень сложности), затем начать играть

После выбора уровня сложности можно начинать играть, открывается игровое поле. Щелкая мышью на соответствующих ячейках пользователь совершает ход, перемещая шашки в указанное положение. Игра ведется с компьютером, поэтому после вашего хода ожидайте хода компьютера. Есть возможность отката игры на несколько ходов назад(CTRL+S,CTRL+N).

Инструкция программиста

В данной программе основным классом является класс LifeWidget, обеспечивающий совершение ходов, как компьютера, так и человека, и Life хранящий информацию о текущей ситуации, а также функции выполняющие ход человека\компьютера и проверяющие на правильность ход шашек\дамок. Основными алгоритмами, исполняющими задачи класса являются ai_mid(), ai_low() здесь осуществляется выбор наилучшего хода и переход к следующей игровой ситуации, mousePressEvent() выполняет обработку нажатий мыши и ход человека, paintEvent() рисует\перерисовывает игровую доску после хода компьютера\человека, также здесь хранится история ходов, которая позволяет откатить игру назад. История\указатели на следующие ходы компьютера хранятся в собственном классе Vector, который включает в себя удобное выполнение операций с одномерным массивом.

Класс Life содержит в себе, во-первых, двумерный массив объектов класс Point(который хранит информацию о положении шашки и её типе) с информацией о расположении на поле шашек, также bool массив cells, хранящий информацию о нажатиях мыши.

Основным является класс ai_Trees, в нём осуществляются алгоритма подсчета ходов, оценка ходов компьютера\человека, построение дерева поиска лучшего хода исходя из оценки функций.

Класс MainWindow это класс интерфейса программы, меню\панель кнопок отката игры\статус строка\вывод центрального виджета игры(игровой доски), также в этом классе осуществляется обработка нажатий\выбора пунктов меню. Кроме того, в классе Field содержится список свободных ячеек для задач класса и, в первую очередь, для генераторов хода.

Весь интерфейс выполнен с использованием Qt-это кросс-платформенный инструментарий разработки ПО на языке программирования C++. Позволяет запускать написанное с его помощью ПО в большинстве современных операционных систем путём простой компиляции программы для каждой ОС без изменения исходного кода. Включает в себя все основные классы, которые могут потребоваться при разработке прикладного программного обеспечения, начиная от элементов графического интерфейса и заканчивая классами для работы с сетью, базами данных и XML. Qt является полностью объектно-ориентированным, легко расширяемым и поддерживающим технику компонентного программирования.

Программа

игра шашки программист алгоритм

Ai_tree.h

#ifndef AI_TREE_H

#define AI_TREE_H

#include "point.h"

#include "Vector.h"

using namespace std;

class Tree

{

public:

~Tree();

size_t move_x;//текущая Х

size_t move_y;//текущая У

size_t move_new_x;//новая Х

size_t move_new_y;//новая У

int rang;// насколько удачный ход для компьютера

point** points;// игровое поле

Vector<Tree*> ai_Trees;// указатели на следующие игровые ситуации

int ai_move_rating(point**,size_t ,size_t ); // оценка хода компьютера

int human_move_rating(point** points,size_t i,size_t j );// оценка хода человека

point** ai_copy_swap(point**,size_t ,size_t,size_t ,size_t ); // определение возможных ходов компьютера

Tree* first(point** points);// первый уровень игрового дерева

Tree* insert_low(Tree*,point**);// новый уровень игрового дерева

Tree* insert_mid(Tree*,point**);// новый уровень игрового дерева

void print(Tree* ,size_t );// вывод игрового дерева

void change_board(point** board,point** new_board);// изменение игрового поля

size_t num_moves(point** ); //количество ходов компьютера

size_t num_moves_human(point** board);//количество ходов человека

bool frag_comp_bool(point** points,size_t x,size_t y);//проверка на съедание компьютером

bool frag_king_ai(point** points,size_t x,size_t y);//проверка на съедание компьютером дамкой

};

#endif

Life.h

#ifndef LIFE_H

#define LIFE_H

#include "point.h"

#include <QtCore>

class Life : public QObject

{

Q_OBJECT

public:

Life(QObject *parent = 0);

virtual ~Life();

void setGridSize(const QSize &size);// установка размера поля

QSize gridSize() const;// возвращение значения размера поля

void setCell(const QPoint &pos, bool value);// установка размера поля

bool cell(const QPoint &pos) const;// возвращает активность клетки

bool Cell_King(size_t x,size_t y);// проверка на дамку

bool move(size_t x,size_t y,size_t new_x,size_t new_y);// ход человека

bool frag(size_t x,size_t y,size_t new_x,size_t new_y);// возможность поедания

bool frag_comp(size_t x,size_t y);// ход компьютера

bool frag_move(size_t x,size_t y,size_t new_x,size_t new_y);// поедание человек

bool frag_king(size_t x,size_t y);// поедание дамкой

bool move_ai_king(size_t x,size_t y);// поедание дамкой компьютера

void refresh();// сброс данных поля

void deleteCells();// удаление данных поля

void new_game();// начало новой игры

bool game_over();// проверка конца игры

point **points; // поле

bool **cells;// нажатия

point tmp;

private:

size_t red_count;// кол-во красных

size_t blue_count;// кол-во синих

QSize gridSizeProperty;// размер поля

};

#endif // LIFE_H

LifeWidget.h

#ifndef LIFEWIDGET_H

#define LIFEWIDGET_H

#include <QtGui>

#include "life.h"

#include "ai_tree.h"

#include "Vector.h"

#include "Vector.cpp"

#include "vector"

class LifeWidget : public QWidget

{

Q_OBJECT

public:

LifeWidget(QWidget *parent = 0);

virtual ~LifeWidget();

void setGridSize(const QSize &size);// установка размера поля

QSize gridSize() const;//возврат размера поля

void setCellSize(int size);//установление размера клетки

int cellSize() const;//возврат размера клетки

void Draw_Cell(QPainter *painter,QBrush PenBrush,int pen_size,

QBrush RectBrush,int x0,int y0,int size);//рисование клетки

void Draw_Ellipse(QPainter *painter,QBrush PenBrush,int pen_size,

QBrush RectBrush,int x0,int y0,int size);//рисование шашки

void ai_low();//низкий уровень сложности

void ai_mid();//средний уровень сложности

void set_game_level(size_t level);//установление режима игры

size_t cout_moves;//количество ходов

Life *life;

size_t player;//текущий игрок

Tree *game;//дерево ходов

point **p;//буфер истории ходов

vector<point**> history_moves;//история ходов

void add_event_history(point**);//добавление в историю

void history_up();//ход вперёд

void history_down();//ход назад

int state_now;//текущее положении истории

protected:

QSize minimumSizeHint() const;

QSize sizeHint() const;

void mousePressEvent(QMouseEvent *event);//обработка нажатий мыши

void paintEvent(QPaintEvent *event);//рисование и изменение доски

private:

size_t game_level;//текущий уровень сложности

bool click1;

bool click2;

int cellSizeProperty;

};

#endif // LIFEWIDGET_H

MainWindow.h

#ifndef MAINWINDOW_H

#define MAINWINDOW_H

#include <QMainWindow>

#include "lifewidget.h"

QT_BEGIN_NAMESPACE

class QAction;

class QListWidget;

class QMenu;

class QTextEdit;

QT_END_NAMESPACE

class MainWindow : public QMainWindow

{

Q_OBJECT

public:

MainWindow();

private slots:

void newLetter();

void save();

void about();

void level_mid();

void level_low();

private:

void createActions();

void createMenus();

void createToolBars();

void createStatusBar();

LifeWidget *life;

QMenu *fileMenu;

QMenu *helpMenu;

QToolBar *fileToolBar;

QToolBar *editToolBar;

QAction *newLetterAct;

QAction *saveAct;

QAction *low;

QAction *mid;

QAction *aboutAct;

QAction *aboutQtAct;

QAction *quitAct;

};

#endif

Point.h

#ifndef POINT_H

#define POINT_H

enum checker

{

RED = 1,// красная шашка

BLUE= 2,// синяя шашка

REDKING = 3,// красная дамка

BLUEKING = 4, // синяя дамка

WHITECELL = 0,// неходовая клетка

EMPTYCELL = 9,// ходовая,пустая клетка

};

class point

{

int x;//У

int y;//Х

int type;//тип

public:

int getX(){return x;}

int getY(){return y;}

int getT(){return type;}

void setT(int t){type=t;}

point(){x=0; y=0; type=0;}

point(const point& p)

{

this->x=p.x;

this->y=p.y;

this->type=p.type;

}

point(int x, int y, int type)

{

this->x = x;

this->y = y;

this->type = type;

}

bool operator == (const point & p )

{

if( x==p.x && y==p.y && type==p.type )return true;

else return false;

}

};

#endif

Vector.h

#ifndef VECTOR_H

#define VECTOR_H

#include <iostream>

using namespace std;

template <class T>

class Vector

{

T* V;

size_t n;

size_t capacity_m;

public:

Vector(size_t=0);

Vector(const Vector&);

size_t size();

void reserve(size_t );

size_t begin();

size_t end();

size_t capacity();

Vector& erase(size_t);

void swap (Vector& );

void push_back(T);

void resize(size_t);

~Vector();

T& operator[](size_t);

};

#endif

ai_tree.cpp

#include <iostream>

#include "Vector.h"

#include "point.h"

#include "life.h"

#include "ai_tree.h"

#include "Vector.cpp"

Tree* Tree::first(point** board)

{

Tree* pv=new Tree;

pv->points= new point*[8];

for (size_t i = 0; i < 8; i++)

pv->points[i]= new point[8];

pv->change_board(pv->points,board);

pv->rang=0;

pv->ai_Trees.resize(num_moves(board));

return pv;

}

Tree::~Tree()

{

for(size_t i=0;i<ai_Trees.size();i++)

delete ai_Trees[i];

ai_Trees=0;

}

Tree* Tree::insert_low(Tree *root,point** points)

{

Tree* pTree=NULL;

size_t num=0;

root->ai_Trees.resize(pTree->num_moves(points));

for (size_t i = 0; i < 8; i++)

{

for (size_t j = 0; j < 8; j++)

{

if(points[i][j].getT()==RED)

{

if((j+1)<8&&(i+1)<8)

{

if((points[i+1][j+1].getT()==EMPTYCELL||

points[i+1][j+1].getT()==BLUE)&&

(root->ai_Trees.size()>num))

{

pTree=new Tree;

pTree->points=ai_copy_swap(points,j,i,j+1,i+1);

pTree->move_x=i;

pTree->move_y=j;

pTree->move_new_x=i+1;

pTree->move_new_y=j+1;

pTree->rang=ai_move_rating(points,i,j);

pTree->ai_Trees.resize(pTree->num_moves(points));

root->ai_Trees[num++]=pTree;

}

}

if((j-1)<8&&(i+1)<8)

{

if((points[i+1][j-1].getT()==EMPTYCELL||

points[i+1][j-1].getT()==BLUE)&&

(root->ai_Trees.size()>num))

{

pTree=new Tree;

pTree->points=ai_copy_swap(points,j,i,j-1,i+1);

pTree->rang=ai_move_rating(points,i,j);

pTree->move_x=i;

pTree->move_y=j;

pTree->move_new_x=i+1;

pTree->move_new_y=j-1;

pTree->ai_Trees.resize(pTree->num_moves(points));

root->ai_Trees[num++]=pTree;

}

}

}

if(points[i][j].getT()==REDKING&&

frag_king_ai(points,i,j))

{

pTree=new Tree;

pTree->rang=ai_move_rating(points,i,j);

pTree->move_x=i;

pTree->move_y=j;

pTree->ai_Trees.resize(pTree->num_moves(points));

root->ai_Trees[num++]=pTree;

}

}

}

return root;

}

Tree* Tree::insert_mid(Tree *root,point** points)

{

Tree* pTree=NULL;

size_t num=0;

root->ai_Trees.resize(pTree->num_moves_human(points));

for (size_t i = 0; i < 8; i++)

{

for (size_t j = 0; j < 8; j++)

{

if(points[i][j].getT()==BLUE)

{

if((j-1)>0&&(j-1)<8&&(i-1)<8&&(i-1)>0)

{

if((points[i-1][j-1].getT()==EMPTYCELL||

points[i-1][j-1].getT()==RED)&&

(root->ai_Trees.size()>num))

{

pTree=new Tree;

pTree->points=ai_copy_swap(points,j,i,j-1,i-1);

pTree->move_x=i;

pTree->move_y=j;

pTree->move_new_x=i-1;

pTree->move_new_y=j-1;

pTree->rang=human_move_rating(points,i,j);

pTree->ai_Trees.resize(0);

root->ai_Trees[num++]=pTree;

}

}

if((j+1)>0&&(j+1)<8&&(i-1)<8&&(i-1)>0)

{

if((points[i-1][j+1].getT()==EMPTYCELL||

points[i-1][j+1].getT()==RED)&&

(root->ai_Trees.size()>num))

{

pTree=new Tree;

pTree->points=ai_copy_swap(points,j,i,j+1,i-1);

pTree->rang=human_move_rating(points,i,j);

pTree->move_x=i;

pTree->move_y=j;

pTree->move_new_x=i-1;

pTree->move_new_y=j+1;

pTree->ai_Trees.resize(0);

root->ai_Trees[num++]=pTree;

}

}

}

if(points[i][j].getT()==BLUEKING&&frag_king_ai(points,i,j))

{

pTree=new Tree;

pTree->rang=ai_move_rating(points,i,j);

pTree->move_x=i;

pTree->move_y=j;

pTree->move_new_x=i+1;

pTree->move_new_y=j-1;

pTree->ai_Trees.resize(pTree->num_moves(points));

root->ai_Trees[num++]=pTree;

}

}

}

return root;

}

void Tree::print(Tree* root,size_t level)

{

if(root)

{

for(size_t i=0;i<root->ai_Trees.size();i++)

print(root->ai_Trees[i],level+1);

for(size_t i=0;i<level;i++)

cout<<" ";

cout<<root->rang<<endl;

}

}

void Tree::change_board(point** board,point** new_board)

{

for (size_t i = 0; i < 8; i++)

for (size_t j = 0; j < 8; j++)

board[i][j]=new_board[i][j];

}

size_t Tree::num_moves_human(point** board)

{

size_t num=0;

for (size_t i = 0; i < 8; i++)

{

for (size_t j = 0; j < 8; j++)

{

if(board[i][j].getT()==BLUE)

{

if((j-1)>0&&(j-1)<8&&(i-1)<8&&(i-1)>0)

if((board[i-1][j-1].getT()==EMPTYCELL||

board[i-1][j-1].getT()==RED)&&

board[i-1][j-1].getT()!=RED) num++;

if((j+1)>0&&(j+1)<8&&(i-1)<8&&(i-1)>0)

if((board[i-1][j+1].getT()==EMPTYCELL||

board[i-1][j+1].getT()==RED)&&

board[i-1][j+1].getT()!=RED) num++;

}

if(board[i][j].getT()==BLUEKING)

if(frag_king_ai(board,i,j)) num++;

}

}

return num;

}

size_t Tree::num_moves(point** board)

{

size_t num=0;

for (size_t i = 0; i < 8; i++)

{

for (size_t j = 0; j < 8; j++)

{

if(board[i][j].getT()==RED)

{

if((j+1)<8&&(i+1)<8)

if((board[i+1][j+1].getT()==EMPTYCELL||

board[i+1][j+1].getT()==BLUE)&&

board[i+1][j+1].getT()!=RED)

num++;

if((j-1)<8&&(i+1)<8)

if((board[i+1][j-1].getT()==EMPTYCELL||

board[i+1][j-1].getT()==BLUE)&&

board[i+1][j-1].getT()!=RED)

num++;

}

if(board[i][j].getT()==REDKING)

if(frag_king_ai(board,i,j)) num++;

}

}

return num;

}

point** Tree::ai_copy_swap(point** board,size_t pos_x,size_t pos_y,size_t new_pos_x,size_t new_pos_y)

{

point** tmp;

point tmp_1;

tmp= new point*[8];

for (size_t i = 0; i < 8; i++)

{

tmp[i]= new point[8];

for (size_t j = 0; j < 8; j++)

{

tmp[i][j]=board[i][j];

}

}

tmp_1=tmp[pos_y][pos_x];

tmp[pos_y][pos_x]=tmp[new_pos_y][new_pos_x];

tmp[new_pos_y][new_pos_x]=tmp_1;

return tmp;

}

int Tree::ai_move_rating(point** points,size_t i,size_t j )

{

int rank=0;

if(points[i][j].getT()==REDKING) rank+=25;

if(frag_king_ai(points,i,j)) rank+=100;

if(frag_comp_bool(points,i,j)) rank+=50;

if((j-1)<8&&(j+1)<8&&(i+1)<8)

{

if(points[i+1][j+1].getT()==EMPTYCELL||points[i+1][j-1].getT()==EMPTYCELL) rank+=15;

}

if((i+1)<8&&(i+2)<8&&(j-1)<8&&(j+2)<8)

{

if(points[i+1][j+1].getT()==BLUE&&points[i+2][j+2].getT()==BLUE) rank-=50;

}

if((i-1)<8&&(j-1)<8&&(j-2)<8&&(i+2)<8)

{

if(points[i+1][j-1].getT()==BLUE&&points[i+2][j-2].getT()==BLUE) rank-=50;

}

if((i+1)<8&&(i+2)<8&&(j+1)<8)

{

if(points[i+1][j+1].getT()==EMPTYCELL&&points[i+2][j].getT()==BLUE) rank+=3;

}

if((i+1)<8&&(i+2)<8&&(j-1)<8&&(j+2)<8)

{

if(points[i+1][j-1].getT()==EMPTYCELL&&points[i+2][j+2].getT()==BLUE) rank+=3;

}

if((i+1)<8&&(i+2)<8&&(j-1)<8&&((j-2)<8||(j+2)<8))

{

if(points[i+1][j-1].getT()==BLUE&&(points[i+2][j-2].getT()==EMPTYCELL||

points[i+2][j+2].getT()==EMPTYCELL)) rank+=50;

}

return rank;

}

int Tree::human_move_rating(point** points,size_t i,size_t j )

{

int rank=0;

if(points[i][j].getT()==BLUEKING) rank+=5;

if(frag_king_ai(points,i,j)) rank+=100;

if((j+1)<8&&(j-1)<8&&(i-1)<8)

{

if(points[i-1][j-1].getT()==EMPTYCELL||points[i-1][j+1].getT()==EMPTYCELL) rank++;

}

if((i-1)<8&&(i-2)<8&&(j+1)<8&&(j-2)<8)

{

if(points[i-1][j-1].getT()==RED&&points[i-2][j-2].getT()==RED) rank-=5;

}

if((i+1)<8&&(j+1)<8&&(j+2)<8&&(i-2)<8)

{

if(points[i-1][j+1].getT()==RED&&points[i-2][j+2].getT()==BLUE) rank-=5;

}

if((i-1)<8&&(i-2)<8&&(j-1)<8)

{

if(points[i-1][j-1].getT()==EMPTYCELL&&points[i-2][j].getT()==RED) rank+=20;

}

if((i-1)<8&&(i-2)<8&&(j+1)<8&&(j-2)<8)

{

if(points[i-1][j+1].getT()==EMPTYCELL&&points[i-2][j-2].getT()==RED) rank+=20;

}

if((i-1)<8&&(i-2)<8&&(j+1)<8&&(j+2)<8)

{

if(points[i-1][j+1].getT()==RED&&(points[i-2][j+2].getT()==EMPTYCELL||

points[i-2][j-2].getT()==EMPTYCELL)) rank+=50;

}

return rank;

}

bool Tree::frag_king_ai(point** points,size_t x,size_t y)

{

if(points[x][y].getT()!=REDKING) return false;

for(size_t i=1;i<8;i++)

{

if((x+i+1)<8&&(y+i+1)<8)

if((points[x+i][y+i].getT()==BLUE||

points[x+i][y+i].getT()==BLUEKING)

&&points[x+i+1][y+i+1].getT()==EMPTYCELL)

return true;

if((x-i-1)>=0&&(y-i-1)>=0&&(x-i-1)<8&&(y-i-1)<8)

if((points[x-i][y-i].getT()==BLUE||

points[x-i][y-i].getT()==BLUEKING)

&&points[x-i-1][y-i-1].getT()==EMPTYCELL)

return true;

if((x+i+1)<8&&(y-i-1)<8&&(x-i-1)>=0)

if((points[x+i][y-i].getT()==BLUE||

points[x+i][y-1].getT()==BLUEKING)

&&points[x+i+1][y-i-1].getT()==EMPTYCELL)

return true;

if((x-i-1)>=0&&(x-i-1)<8&&(y+i+1)<8)

if((points[x-i][y+i].getT()==BLUE||

points[x-i][y+i].getT()==BLUEKING)

&&points[x-i-1][y+i+1].getT()==EMPTYCELL)

return true;

}

return false;

}

bool Tree::frag_comp_bool(point** points,size_t x,size_t y)

{

if((x+1)<8&&(x+2)<8&&(y-1)<8&&(y-2)<8)

if(points[x+1][y-1].getT()==BLUE&&

points[x+2][y-2].getT()==EMPTYCELL)

return true;

if((x+1)<8&&(x+2)<8&&(y+1)<8&&(y+2)<8)

if(points[x+1][y+1].getT()==BLUE&&

points[x+2][y+2].getT()==EMPTYCELL)

return true;

return false;

}

Life.cpp

#include <QtCore>

#include "life.h"

#include <iostream>

using namespace std;

Life::Life(QObject *parent)

: QObject(parent)

{

cells = 0;

points = 0;

setGridSize(QSize(8, 8));

}

Life::~Life()

{

}

void Life::new_game()

{

for (size_t i = 0; i < gridSize().width(); i++)

{

for (size_t j = 0; j < gridSize().height(); j++)

{

cells[i][j] = false;

if(i<=2&&(i+j)&1)

points[i][j]=point(i,j,RED);

else if(i>=5&&i<=7&&(i+j)&1)

points[i][j]=point(i,j,BLUE);

else if(i>=3&&i<=4&&(i+j)&1)

points[i][j]=point(i,j,EMPTYCELL);

else if(!(i+j)&1)

points[i][j]=point(i,j,WHITECELL);

}

}

}

bool Life::game_over()

{

red_count=0;

blue_count=0;

for (size_t i = 0; i < gridSize().width(); i++)

{

for (size_t j = 0; j < gridSize().height(); j++)

{

if(points[i][j].getT()==RED) red_count++;

else if (points[i][j].getT()==BLUE)

blue_count++;

else if (points[i][j].getT()==BLUEKING)

blue_count++;

else if (points[i][j].getT()==REDKING)

red_count++;

}

}

if(red_count==0)

return true;

else if(blue_count==0)

return true;

return false;

}

void Life::setGridSize(const QSize &size)

{

if (cells != 0) {

deleteCells();

}

gridSizeProperty = size;

cells = new bool*[gridSize().width()];

points= new point*[gridSize().width()];

for (size_t i = 0; i < gridSize().width(); i++)

{

cells[i] = new bool[gridSize().height()];

points[i]= new point[gridSize().width()];

for (size_t j = 0; j < gridSize().height(); j++)

{

cells[i][j] = false;

if(i<=2&&(i+j)&1)

points[i][j]=point(i,j,RED);

else if(i>=5&&i<=7&&(i+j)&1)

points[i][j]=point(i,j,BLUE);

else if(i>=3&&i<=4&&(i+j)&1)

points[i][j]=point(i,j,EMPTYCELL);

else if(!(i+j)&1)

points[i][j]=point(i,j,WHITECELL);

}

}

}

QSize Life::gridSize() const

{

return gridSizeProperty;

}

bool Life::frag_comp(size_t x,size_t y)

{

if((x+1)<8&&(x+2)<8&&(y-1)<8&&(y-2)<8)

{

if((points[x+1][y-1].getT()==BLUE||

points[x+1][y-1].getT()==BLUEKING)&&

points[x+2][y-2].getT()==EMPTYCELL)

{

move(x,y,x+2,y-2);

points[(x+x+2)/2][(y+y-2)/2].setT(EMPTYCELL);

frag_comp(x+2,y-2);

return true;

}

}

if((x+1)<8&&(x+2)<8&&(y+1)<8&&(y+2)<8)

{

if((points[x+1][y+1].getT()==BLUE

||points[x+1][y-1].getT()==BLUEKING)

&&points[x+2][y+2].getT()==EMPTYCELL)

{

move(x,y,x+2,y+2);

points[(x+x+2)/2][(y+y+2)/2].setT(EMPTYCELL);

frag_comp(x+2,y+2);

return true;

}

}

return false;

}

bool Life::frag(size_t x,size_t y,size_t new_x,size_t new_y)

{

if(points[new_x][new_y].getT()==EMPTYCELL&&

points[(x+new_x)/2][(y+new_y)/2].getT()==RED||

points[(x+new_x)/2][(y+new_y)/2].getT()==REDKING)

return true;

return false;

}

bool Life::frag_move(size_t x,size_t y,size_t new_x,size_t new_y)

{

if(points[x][y].getT()==BLUE||points[x][y].getT()==BLUEKING)

{

if(points[x][y].getT()==BLUEKING)

{

for(size_t i=1 ;i<8;i++)

{

if((x+i)<8&&(y+i)<8)

{

if(points[x+i][y+i].getT()==RED||

points[x+i][y+i].getT()==REDKING)

{

move(x,y,new_x,new_y);

points[x+i][y+i].setT(EMPTYCELL);

return true;

}

}

if((x-i)<8&&(y-i)<8)

{

if(points[x-i][y-i].getT()==RED||

points[x-i][y-i].getT()==REDKING)

{

move(x,y,new_x,new_y);

points[x-i][y-i].setT(EMPTYCELL);

return true;

}

}

if((x+i)<8&&(y-i)<8)

{

if(points[x+i][y-i].getT()==RED||

points[x+i][y-i].getT()==REDKING)

{

move(x,y,new_x,new_y);

points[x+i][y-i].setT(EMPTYCELL);

return true;

}

}

if((x-i)<8&&(y+i)<8)

{

if(points[x-i][y+i].getT()==BLUE&&

points[x-i][y+i].getT()==EMPTYCELL)

{

move(x,y,new_x,new_y);

points[x-i][y+i].setT(EMPTYCELL);

return true;

}

}

}

}

else if(points[x][y].getT()==BLUE)

{

move(x,y,new_x,new_y);

points[(x+new_x)/2][(y+new_y)/2].setT(EMPTYCELL);

if((new_y-2)>0&&(new_y-2)<8&&(new_x-2)<8&&(new_x-2)>=0)

if(frag(new_x,new_y,new_x-2,new_y-2))

frag_move(new_x,new_y,new_x-2,new_y-2);

if((new_y+2)>0&&(new_y+2)<8&&(new_x-2)<8&&(new_x-2)>=0)

if(frag(new_x,new_y,new_x-2,new_y+2))

frag_move(new_x,new_y,new_x-2,new_y+2);

return true;

}

}

return false;

}

bool Life::frag_king(size_t x,size_t y)

{

if(points[x][y].getT()!=REDKING) return false;

for(size_t i=1;i<8;i++)

{

if((x+i+1)<8&&(y+i+1)<8)

{

if(points[x+i][y+i].getT()==RED) continue;

if((points[x+i][y+i].getT()==BLUE||

points[x+i][y+i].getT()==BLUEKING)&&

points[x+i-1][y+i-1].getT()!=BLUE&&

points[x+i+1][y+i+1].getT()==EMPTYCELL)

{

move(x,y,x+i+1,y+i+1);

points[x+i][y+i].setT(EMPTYCELL);

frag_king(x+i+1,y+i+1);

return true;

}

}

if((x-i-1)<8&&(y-i-1)<8)

{

if(points[x-i][y-i].getT()==RED) continue;

if((points[x-i][y-i].getT()==BLUE||

points[x-i][y-i].getT()==BLUEKING)&&

points[x-i-1][y-i-1].getT()!=BLUE

&&points[x-i-1][y-i-1].getT()==EMPTYCELL)

{

move(x,y,x-i-1,y-i-1);

points[x-i][y-i].setT(EMPTYCELL);

frag_king(x-i-1,y-i-1);

return true;

}

}

if((x+i+1)<8&&(y-i-1)<8)

{

if(points[x+i][y-i].getT()==RED) continue;

if((points[x+i][y-i].getT()==BLUE||

points[x+i][y-i].getT()==BLUEKING)&&

points[x+i-1][y-i-1].getT()!=BLUE

&&points[x+i+1][y-i-1].getT()==EMPTYCELL)

{

move(x,y,x+i+1,y-i-1);

points[x+i][y-i].setT(EMPTYCELL);

frag_king(x+i+1,y-i-1);

return true;

}

}

if((x-i-1)<8&&(y+i+1)<8)

{

if(points[x-i][y+i].getT()==RED) continue;

if((points[x-i][y+i].getT()==BLUE||

points[x-i][y+i].getT()==BLUEKING)&&

points[x-i-1][y+i-1].getT()!=BLUE

&&points[x-i-1][y+i+1].getT()==EMPTYCELL)

{

move(x,y,x-i-1,y+i+1);

points[x-i][y+i].setT(EMPTYCELL);

frag_king(x-i-1,y+i+1);

return true;

}

}

}

return false;

}

void Life::refresh()

{

for (size_t i = 0; i < gridSize().width(); i++)

for (size_t j = 0; j < gridSize().height(); j++)

cells[i][j]=false;

}

bool Life::move_ai_king(size_t x,size_t y)

{

if(points[x][y].getT()==REDKING)

{

if((x-1)>0&&(y-1)<8&&(x-1)<8&&(x-1)>0)

if(points[x-1][y-1].getT()==EMPTYCELL&&

points[x-1][y-1].getT()!=RED)

{

move(x,y,x-1,y-1);

return true;

}

if((y+1)>0&&(y+1)<8&&(x-1)<8&&(x-1)>0)

if(points[x-1][y+1].getT()==EMPTYCELL&&

points[x-1][y+1].getT()!=RED)

{

move(x,y,x-1,y+1);

return true;

}

}

return false;

}

bool Life::move(size_t x,size_t y,size_t new_x,size_t new_y)

{

point buf;

buf=points[new_x][new_y];

points[new_x][new_y]=points[x][y];

points[x][y]=buf;

return true;

}

void Life::setCell(const QPoint &pos, bool value)

{

if (gridSize().width() > pos.x() &&

gridSize().height() > pos.y())

{

cells[pos.x()][pos.y()] = value;

}

}

bool Life::cell(const QPoint &pos) const

{

if (gridSize().width() > pos.x() &&

gridSize().height() > pos.y())

{

return cells[pos.x()][pos.y()];

}

return false;

}

bool Life::Cell_King(size_t x,size_t y)

{

if(points[x][y].getT()==RED&&x==7)

{

points[x][y].setT(REDKING);

return true;

}

else if(points[x][y].getT()==BLUE&&x==0)

{

points[x][y].setT(BLUEKING);

return true;

}

return false;

}

void Life::deleteCells()

{

for (size_t i = 0; i < gridSize().width(); i++)

{

delete [] cells[i];

delete [] points[i];

}

delete [] cells;

delete [] points;

cells = 0;

points= 0;

}

LifeWidget.cpp

#include <QtGui>

#include "life.h"

#include "lifewidget.h"

#include "ai_tree.h"

#include "point.h"

#include <iostream>

#include "mainwindow.h"

using namespace std;

LifeWidget::LifeWidget(QWidget *parent)

: QWidget(parent)

{

life = new Life(this);

player=BLUE;

cout_moves=1;

click1=FALSE;

click2=FALSE;

state_now=-1;

game_level=3;

setCellSize(70);

setGridSize(QSize(8, 8));

game=game->first(life->points);

p = new point*[8];

for (size_t i = 0; i < 8; i++)

{

p[i] = new point[8];

for (size_t j = 0; j < 8; j++)

p[i][j]=point();

}

game->change_board(p,life->points);

add_event_history(p);

}

LifeWidget::~LifeWidget()

{

for (size_t i = 0; i < 8; i++)

delete p[i];

}

void LifeWidget::add_event_history(point** new_move)

{

point** tmp_2=new_move;

tmp_2 = new point*[8];

for (size_t i = 0; i < 8; i++)

{

tmp_2[i] = new point[8];

for (size_t j = 0; j < 8; j++)

tmp_2[i][j]=new_move[i][j];

}

history_moves.push_back(tmp_2);

state_now++;

}

void LifeWidget::set_game_level(size_t level)

{

if(level==1)

game_level=1;

else if(level==0)

game_level=0;

}

void LifeWidget::history_up()

{

state_now++;

if(state_now>=history_moves.size())

{

state_now--;

return;

}

else

{

point **p=history_moves[state_now];

game->change_board(life->points,p);

player=BLUE;

update();

}

}

void LifeWidget::history_down()

{

state_now--;

if(state_now<=0)

{

state_now++;

return;

}

else

{

point **p=history_moves[state_now];

game->change_board(life->points,p);

player=BLUE;

update();

}

}

void LifeWidget::setGridSize(const QSize &size)

{

life->setGridSize(size);

adjustSize();

update();

}

QSize LifeWidget::gridSize() const

{

return life->gridSize();

}

void LifeWidget::setCellSize(int size)

{

cellSizeProperty = size;

adjustSize();

update();

}

int LifeWidget::cellSize() const

{

return cellSizeProperty;

}

QSize LifeWidget::minimumSizeHint() const

{

return QSize(gridSize().width() * cellSize() , gridSize().height() * cellSize());

}

QSize LifeWidget::sizeHint() const

{

return minimumSizeHint();

}

void LifeWidget::mousePressEvent(QMouseEvent *event)

{

if(!(game_level==1||game_level==0)) return;

QPoint pos = QPoint(event->pos().x() / cellSize(), event->pos().y() / cellSize());

if(player==BLUE)

{

if((pos.y()+pos.x())&1&&(life->points[pos.y()][pos.x()].getT()==BLUE||

life->points[pos.y()][pos.x()].getT()==BLUEKING))

{

if (event->button() == Qt::RightButton)

{

click1=false;

click2=false;

life->refresh();

update();

return;

}

}

if(click1==false&&(pos.y()+pos.x())&1&&(life->points[pos.y()][pos.x()].getT()==BLUE||

life->points[pos.y()][pos.x()].getT()==BLUEKING))

{

click1=true;

if (event->button() == Qt::LeftButton && !life->cell(pos)&&click1)

{

life->setCell(pos, true);

point click(pos.y(),pos.x(),life->points[pos.y()][pos.x()].getT());

life->tmp=click;

click2=true;

update();

return;

}

}

else if (event->button() == Qt::LeftButton&&!life->cell(pos)&&click1&&click2&&(pos.y()+pos.x())&1

&&life->points[pos.y()][pos.x()].getT()==EMPTYCELL)

{

life->setCell(pos, true);

if(life->points[life->tmp.getX()][life->tmp.getY()].getT()==BLUEKING)

{

game->change_board(p,life->points);

add_event_history(p);

if(life->frag_move(life->tmp.getX(),life->tmp.getY(),pos.y(),pos.x()))

{

life->refresh();

click1=false;

click2=false;

player=RED;

update();

return;

}

else

{

life->move(life->tmp.getX(),life->tmp.getY(),pos.y(),pos.x());

life->refresh();

click1=false;

click2=false;

player=RED;

update();

return;

}

}

if(life->frag(life->tmp.getX(),life->tmp.getY(),pos.y(),pos.x()))

{

game->change_board(p,life->points);

add_event_history(p);

if((life->tmp.getX()-2)==pos.y()&&((life->tmp.getY()-2)==pos.x()||(life->tmp.getY()+2)==pos.x()))

{

life->frag_move(life->tmp.getX(),life->tmp.getY(),pos.y(),pos.x());

life->refresh();

click1=false;

click2=false;

player=RED;

update();

if(life->game_over())

{

life->new_game();

player=BLUE;

return;

}

}

else

{

life->refresh();

click1=false;

click2=false;

player=BLUE;

}

}

else

{

game->change_board(p,life->points);

add_event_history(p);

if((life->tmp.getX()-1)==pos.y()&&((life->tmp.getY()-1)==pos.x()||(life->tmp.getY()+1)==pos.x()))

{

life->move(life->tmp.getX(),life->tmp.getY(),pos.y(),pos.x());

life->refresh();

click1=false;

click2=false;

player=RED;

}

else

{

click1=false;

click2=false;

player=BLUE;

life->refresh();

}

}

}

}

}

void LifeWidget::Draw_Cell(QPainter *painter,QBrush PenBrush,int pen_size,QBrush RectBrush,int x0,int y0,int size)

{

painter->setRenderHint(QPainter::Antialiasing);

painter->setPen(QPen(PenBrush,pen_size, Qt::SolidLine));

painter->setBrush(RectBrush);

painter->drawRect(x0, y0, size, size);

}

void LifeWidget::Draw_Ellipse(QPainter *painter,QBrush PenBrush,int pen_size,QBrush RectBrush,int x0,int y0,int size)

{

painter->setRenderHint(QPainter::Antialiasing);

painter->setPen(QPen(PenBrush,pen_size, Qt::SolidLine));

painter->setBrush(RectBrush);

painter->drawEllipse(x0, y0, size, size);

}

void LifeWidget::ai_low()

{

if(player==RED)

{

game->insert_low(game,life->points);

int max=game->ai_Trees[0]->rang;

int ii=0;

for(size_t i=0;i<game->ai_Trees.size();i++)

{

if(game->ai_Trees[i]->rang>max)

{

ii=i;

max=game->ai_Trees[i]->rang;

}

}

game=game->ai_Trees[ii];

if(game->frag_king_ai(life->points,game->move_x,game->move_y))

{

life->frag_king(game->move_x,game->move_y);

player=BLUE;

update();

return;

}

else if(life->frag_comp(game->move_x,game->move_y))

{

player=BLUE;

update();

return;

}

else if(life->move_ai_king(game->move_x,game->move_y))

{

player=BLUE;

update();

return;

}

else

{

life->move(game->move_x,game->move_y,game->move_new_x,game->move_new_y);

player=BLUE;

update();

return;

}

player=BLUE;

update();

}

}

void LifeWidget::ai_mid()

{

if(player==RED)

{

Tree* tmp=game;

cout_moves++;

game->insert_low(game,life->points);

int maxI=game->ai_Trees[0]->rang;

int iii=0;

for(size_t i=0;i<game->ai_Trees.size();i++)

{

if(game->ai_Trees[i]->rang>maxI)

{

iii=i;

maxI=game->ai_Trees[i]->rang;

}

}

if(game->frag_king_ai(life->points,game->ai_Trees[iii]->move_x,game->ai_Trees[iii]->move_y))

{

life->frag_king(game->ai_Trees[iii]->move_x,game->ai_Trees[iii]->move_y);

player=BLUE;

update();

return;

}

else if(life->frag_comp(game->ai_Trees[iii]->move_x,game->ai_Trees[iii]->move_y))

{

player=BLUE;

update();

return;

}

else if(life->move_ai_king(game->ai_Trees[iii]->move_x,game->ai_Trees[iii]->move_y))

{

player=BLUE;

update();

return;

}

for(size_t i=0;i<game->ai_Trees.size();i++)

game->insert_mid(game->ai_Trees[i],game->ai_Trees[i]->points);

Vector<int> childs_sum(game->ai_Trees.size());

for(size_t i=0;i<game->ai_Trees.size();i++)

for(size_t j=0;j<game->ai_Trees[i]->ai_Trees.size();j++)

childs_sum[i]+=game->ai_Trees[i]->ai_Trees[j]->rang;

int ii=0;

int max=childs_sum[0];

for(size_t i=0;i<childs_sum.size();i++)

if(childs_sum[i]>max)

{

ii=i;

max=childs_sum[i];

}

game=game->ai_Trees[ii];

if(1)

{

life->move(game->move_x,game->move_y,game->move_new_x,game->move_new_y);

player=BLUE;

update();

return;

}

player=BLUE;

update();

}

}

void LifeWidget::paintEvent(QPaintEvent* /*event*/)

{

QPainter p(this);

if(game_level==1) ai_mid();

else if(game_level==0) ai_low();

if(life->game_over())

{

life->new_game();

player=BLUE;

return;

}

for (int i = 0; i < gridSize().width(); i++) //KING

for (int j = 0; j < gridSize().height(); j++)

life->Cell_King(i,j);

for (int i = 0; i < gridSize().width(); i++) //рисование поля

{

for (int j = 0; j < gridSize().height(); j++)

{

if((i+j)&1)

{

Draw_Cell(&p,Qt::black,0,Qt::gray,i * cellSize(),j * cellSize(),cellSize());

if(life->points[j][i].getT()==RED)

{

Draw_Ellipse(&p,Qt::black,2,Qt::red,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}

else if(life->points[j][i].getT()==BLUE)

{

Draw_Ellipse(&p,Qt::black,2,Qt::blue,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}

else if(life->points[j][i].getT()==REDKING)

{

Draw_Ellipse(&p,Qt::green,4,Qt::red,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}

else if(life->points[j][i].getT()==BLUEKING)

{

Draw_Ellipse(&p,Qt::green,4,Qt::blue,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}

}

else if(life->points[j][i].getT()==WHITECELL)

{

Draw_Cell(&p,Qt::black,0,Qt::white,i * cellSize(),j * cellSize(),cellSize());

for (int i = 0; i < gridSize().width(); i++) //рисование желтой клетки

for (int j = 0; j < gridSize().height(); j++)

if(life->cell(QPoint(i, j))&&(i+j)&1)

{

Draw_Cell(&p,Qt::yellow,6,Qt::gray,i * cellSize(),j * cellSize(),cellSize());

if(life->points[j][i].getT()==RED)

{

Draw_Ellipse(&p,Qt::black,2,Qt::red,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}

else if(life->points[j][i].getT()==BLUE)

{

Draw_Ellipse(&p,Qt::black,2,Qt::blue,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}

else if(life->points[j][i].getT()==REDKING)

{

Draw_Ellipse(&p,Qt::green,4,Qt::red,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}

else if(life->points[j][i].getT()==BLUEKING)

{

Draw_Ellipse(&p,Qt::green,4,Qt::blue,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}

}

update();

}

MainWindow.cpp

#include <QtGui>

#include "mainwindow.h"

#include "lifewidget.h"

#include "ai_tree.h"

#include "point.h"

MainWindow::MainWindow()

{

QScrollArea scroll;

life = new LifeWidget(&scroll);

setCentralWidget(life);

scroll.show();

life->show();

life->setCellSize(70);

createActions();

createMenus();

createToolBars();

createStatusBar();

setWindowTitle(tr("Checkers"));

setUnifiedTitleAndToolBarOnMac(true);

}

void MainWindow::newLetter()

{

life->history_down();

update();

}

void MainWindow::save()

{

life->history_up();

update();

}

void MainWindow::about()

{

QMessageBox::about(this, tr("About Checkers"),

tr("<b> Checkers //</b>"

"<b> NN,2010</b>"));

}

void MainWindow::level_mid()

{

life->set_game_level(1);

}

void MainWindow::level_low()

{

life->set_game_level(0);

}

void MainWindow::createActions()

{

newLetterAct = new QAction(QIcon("save.png"), tr("&Back"),

this);

newLetterAct->setShortcuts(QKeySequence::New);

newLetterAct->setStatusTip(tr("Back_move"));

connect(newLetterAct, SIGNAL(triggered()), this, SLOT(newLetter()));

saveAct = new QAction(QIcon("new.png"), tr("&Forward"), this);

saveAct->setShortcuts(QKeySequence::Save);

saveAct->setStatusTip(tr("Forward_move"));

connect(saveAct, SIGNAL(triggered()), this, SLOT(save()));

low = new QAction(QIcon("low.png"),tr("low_level"), this);

low->setStatusTip(tr("low_level"));

connect(low, SIGNAL(triggered()), this, SLOT(level_low()));

mid = new QAction(QIcon("mid.png"),tr("&mid_level"), this);

mid->setStatusTip(tr("mid_level"));

connect(mid, SIGNAL(triggered()), this, SLOT(level_mid()));

quitAct = new QAction(tr("&Quit"), this);

quitAct->setShortcuts(QKeySequence::Quit);

quitAct->setStatusTip(tr("Quit the application"));

connect(quitAct, SIGNAL(triggered()), this, SLOT(close()));

aboutAct = new QAction(tr("&About"), this);

aboutAct->setStatusTip(tr("Show the application's About box"));

connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));

aboutQtAct = new QAction(tr("About &Qt"), this);

aboutQtAct->setStatusTip(tr("Show the Qt library's About box"));

connect(aboutQtAct, SIGNAL(triggered()), qApp, SLOT(aboutQt()));

}

void MainWindow::createMenus()

{

fileMenu = menuBar()->addMenu(tr("&File"));

fileMenu->addAction(newLetterAct);

fileMenu->addAction(saveAct);

fileMenu->addSeparator();

fileMenu->addAction(low);

fileMenu->addAction(mid);

fileMenu->addSeparator();

fileMenu->addAction(quitAct);

menuBar()->addSeparator();

helpMenu = menuBar()->addMenu(tr("&Help"));

helpMenu->addAction(aboutAct);

helpMenu->addAction(aboutQtAct);

}

void MainWindow::createToolBars()

{

fileToolBar = addToolBar(tr("File"));

fileToolBar->addAction(newLetterAct);

fileToolBar->addAction(saveAct);

}

void MainWindow::createStatusBar()

{

statusBar()->showMessage(tr("Ready"));

}

Vector.cpp

#include <iostream>

#include "Vector.h"

using namespace std;

template <class T>

Vector<T>::~Vector()

{

delete[] V;

V=0;

}

template <class T>

size_t Vector<T>::size()

{

return n;

}

template <class T>

size_t Vector<T>::begin()

{

return 0;

}

template <class T>

size_t Vector<T>::end()

{

return n;

}

template <class T>

size_t Vector<T>::capacity()

{

return capacity_m;

}

template <class T>

void Vector<T>::swap(Vector& Vect)

{

std::swap (V, Vect.V);

std::swap (n, Vect.n);

std::swap (capacity_m, Vect.capacity_m);

}

template <class T>

Vector<T>::Vector(const Vector& Vect)

{

n=Vect.n;

capacity_m=Vect.capacity_m;

V=new T[n];

for(size_t i=0;i<n;i++)

(*this)[i]=Vect.V[i];

}

template <class T>

T& Vector<T>::operator [](size_t i)

{

if(i<n) return V[i];

throw out_of_range("vector index");

}

template <class T>

Vector<T>::Vector(size_t new_size)

{

n=new_size;

capacity_m=new_size;

V=new T[new_size];

for(size_t i=0;i<new_size;i++)

(*this)[i]=T();

}

template <class T>

Vector<T>& Vector<T> ::erase(size_t k)

{

if(k>=n) throw out_of_range("vector index");

Vector buf=*this;

n--;

for(size_t i=0;i<n;i++)

if(i!=k)(*this)[i]=buf[i];

else

{

(*this)[i]=buf[i+1];

k++;

}

return *this;

}

template <class T>

void Vector<T> ::push_back(T new_item)

{

if ( size() == capacity() ) reserve ( capacity() * 2 );

(*this)[n++] = new_item;

}

template <class T>

void Vector<T>::resize(size_t new_size)

{

if ( new_size <= size() )

{

n=new_size;

return;

}

if ( new_size > capacity() )

reserve ( new_size * 2 );

delete[] V;

V=new T[new_size];

while ( n != new_size )

(*this)[n++] = T();

}

template <class T>

void Vector<T>::reserve (size_t new_cap)

{

if (new_cap <= capacity() ) return;

Vector buf;

buf.V = new T[new_cap];

buf.capacity_m = new_cap;

buf.n = n;

for (size_t i=0; i<n; ++i)

buf[i] = (*this)[i];

buf.swap (*this);

}

Результаты работы программы



Размещено на Allbest.ru