Указатель на класс

// ---------------------------------------------------------------------------
 
#include <vcl.h>
#include <stdio.h>
#pragma hdrstop
 
#include "Unit1.h"
#include <vector>
#include <time.h> // для рандома
// ---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
 
int numev = 0; // счетчик, необходимый для смены состояний построения графа
int kv = 0; // количество вершин
int line; // переменная, необходимая для формирования матрицы смежности
bool select = false;
int **matrix; // выделение памяти для будущей матрицы смежности
AnsiString way; // строка для вывода результатов в файл и на экран
int *buf; // указатель на буфер
bool mark = false;
int kvdel = 0;
int viX0, viY0; // для перетаскивания
bool fMove;
bool end = false; // перетаскивания 2
 
// классы
class vershina {
public:
 
    int x, y;
    int razmer_ver;
    int color;
 
    void randXY() {
        x = rand() % 400;
        y = rand() % 300;
    }
 
    void razmer_plus(int tg) {
        razmer_ver = razmer_ver * tg;
    }
 
    void razmer_minus(int fd) {
        razmer_ver = razmer_ver / fd;
    }
};
 
 
 
class rebro {
public:
    int razmer;
    int ot1;
    int do2;
 
    void razmer_plus(int t) {
        razmer = razmer * t;
    }
 
    void razmer_minus(int kl) {
        razmer = razmer / kl;
    }
};
 
// -----------------------------
std::vector<vershina>mas; // массив классов вершин
std::vector<rebro>mas2; // массив классов ребер
 
// перерисовка
void pererisovka() {
    // очистка компонента
    Form1->Image1->Picture->Bitmap->FreeImage();
    Form1->Image1->Picture->Bitmap = NULL;
 
    // рисуем линии
    for (int i = 0; i < kv; i++)
        for (int j = 0; j < kv; j++) {
            if (matrix[i][j] == 1) {
                for (int g = 0; g < kv; g++) { // по классам ребер
                    if ((mas2[g].ot1 == i && mas2[g].do2 == j) ||
                        (mas2[g].ot1 == j && mas2[g].do2 == i)) {
                        Form1->Image1->Canvas->Pen->Width = mas2[g].razmer;
                        Form1->Image1->Canvas->Pen->Color = mas2[g].color;
                        Form1->Image1->Canvas->MoveTo(mas[i].x, mas[i].y);
                        // ставится точка
                        Form1->Image1->Canvas->LineTo(mas[j].x, mas[j].y);
                        // и проводим к другой
                    }
                }
            }
        }
 
    // рисуем точки
    int io = 1;
    for (int i = 0; i <= mas.size() - 1; i++) {
        Form1->Image1->Canvas->Pen->Color = mas[i].color;
        Form1->Image1->Canvas->Pen->Width = mas[i].razmer_ver;
        Form1->Image1->Canvas->MoveTo(mas[i].x, mas[i].y);
        Form1->Image1->Canvas->LineTo(mas[i].x, mas[i].y);
        Form1->Image1->Canvas->TextOut(mas[i].x - 5, mas[i].y - 5,
            AnsiString(io));
        io++;
    }
 
}
 
// ---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) {
    matrix = new int* [100]; // создать массив для матрицы смежности
    for (int i = 0; i < 100; i++) // обнулить этот массив
    {
        matrix[i] = new int[100];
        for (int j = 0; j < 100; j++) {
            matrix[i][j] = 0;
        }
    }
}
// ---------------------------------------------------------------------------
 
// Функция проверки на повторы вершин в цепи
int __fastcall Repeat(int i, int num) {
    for (int j = 0; j < num; j++) // цикл поиска такой же вершины
    {
        if (buf[j] == i)
            return 1; // если  такая найдена, то повтор есть
    }
    return 0; // нет повтора
}
 
// Функция для поиска новых вершин в цепи
void __fastcall Ways(int ver, int num) {
    select = false;
    if (mark == true) // если вершины уже удалялись
    {
        kvdel = buf[num]; // начинать отсчет вершин с
    }
    else
        kvdel = 0; // иначе обнулить этот счетчик
    mark = false;
    for (int i = kvdel; i < kv; i++) // цикл поиска возможных вершин
    {
        if (matrix[ver][i] == 0)
            continue; // если нет ребра, следующий
        if (Repeat(i, num))
            continue; // если вершина уже была, следующий
        if (i == buf[num])
            continue;
        ver = i;
        select = true; // отметка, что вершину нашли
        break;
    }
    if (select == true) // если вершина найдена
    {
        buf[num] = ver; // добавить ее в цепь
        num++; // увеличить счетчик
        Ways(ver, num); // рекурсивно вызвать с новыми параметрами
    }
    else // если вершина не найдена
    {
        if (num == kv) // если длина цепи равна количеству вершин
        {
            way = buf[0] + 1;
            for (int i = 1; i < kv; i++) {
                way += ',';
                way += buf[i] + 1;
            }
            if (matrix[buf[kv - 1]][0] != 0)
                way += ",1";
            Form1->Results->Items->Add(way); // вывод результата на экран
            way += '\n';
        }
        way = buf[0] + 1;
        for (int i = 1; i < num; i++) {
            way += ',';
            way += buf[i] + 1;
 
        }
        way += '\n';
        num--; // уменьшаем счетчик
        mark = false;
        if (num != 0) // если счетчик вершины не равен 0
        {
            if (num != kv - 1)
                buf[num + 1] = NULL;
            // и не равен количеству вершин, то обнулить
            // следующую ячейку буфера
            mark = true; // отметка о удалении вершины
            Ways(buf[num - 1], num); // поиск следующей вершины
        }
    }
}
 
// ----------------------------------------------------------------------------
// Функция поиска гамильтоновых циклов
void __fastcall Gamilton(void) {
    buf = new int[kv]; // создание буфера
    buf[0] = 0;
    for (int i = 0; i < kv; i++) // обнуление буфера
    {
        buf[i] = NULL;
    }
 
    Ways(0, 1); // вызов функции для поиска новых вершин в цепи
 
}
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::Image1MouseDown(TObject *Sender, TMouseButton Button,
    TShiftState Shift, int X, int Y) {
    if (numev == 0) {
        // рядом выводится номер вершины
 
        vershina pt ;
        pt.x = X;
        pt.y = Y;
        pt.razmer_ver = 25;
        pt.color = 33023;
        mas.push_back(pt); // добавляет элемент в конец массива
        kv++;
        pererisovka();
    }
    if (numev == 1) // построение ребер
    {
        for (int i = 0; i < kv; i++) {
            if ((X > (mas[i].x - 5)) && (X < (mas[i].x + 5))) {
                if ((Y > (mas[i].y - 5)) && (Y < (mas[i].y + 5))) {
                    if (select == false) // если вершина отмечена первой
                    {
                        Image1->Canvas->Pen->Color = clRed;
                        // отметить ее красным цветом
                        Image1->Canvas->Pen->Width = 7;
                        Image1->Canvas->MoveTo(mas[i].x, mas[i].y);
                        Image1->Canvas->LineTo(mas[i].x, mas[i].y);
                        line = i; // занести в переменную номер вершины
                        select = true;
                        // поставить отметку, что одна вершина уже выделена
                    }
                    else // иначе
                    {
                        Image1->Canvas->Pen->Color = clBlack;
                        Image1->Canvas->Pen->Width = 10;
                        Image1->Canvas->MoveTo(mas[line].x, mas[line].y);
                        Image1->Canvas->LineTo(mas[line].x, mas[line].y);
                        Image1->Canvas->Pen->Width = 3;
                        Image1->Canvas->LineTo(mas[i].x, mas[i].y);
                        // провести линию
                        matrix[line][i] = 1;
                        // поставить отметку о ребре в матрице смежности
                        matrix[i][line] = 1;
                        select = false;
                        // ребро построено, выделенных вершин нет
                        rebro as ;
                        as.razmer = 10;
                        as.ot1 = i;
                        as.do2 = line;
                        as.color = 000;
                        mas2.push_back(as);// добавляет элемент в конец массива
                        pererisovka();
                    }
                    break;
                }
            }
        }
 
    }
    if (numev == 4) {
        // Запомнить где
        viX0 = X;
        viY0 = Y;
        // Будем тащить
        fMove = true;
    }
}
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender) {
    numev = 0;
}
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::Button4Click(TObject *Sender) {
    numev = 1;
}
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::Button5Click(TObject *Sender) {
    Results->Items->Clear();
    Gamilton();
    if (Form1->Results->Items->Count == 0) {
        Form1->Results->Items->Add(" циклов нет");
    }
    pererisovka();
}
 
// ---------------------------------------------------------------------------
// изменить размер вершины
void __fastcall TForm1::Button1Click(TObject *Sender) {
    int r_v = StrToInt(Edit1->Text);
    int n_v = StrToInt(Edit2->Text);
    n_v--;
    for (int i = 0; i <= mas.size() - 1; i++) {
        if (i == n_v) {
            mas[i].razmer_ver = r_v;
        }
    }
 
    pererisovka();
}
 
// ---------------------------------------------------------------------------
// изменить цвет
void __fastcall TForm1::Button2Click(TObject *Sender) {
    int с_v = StrToInt(Edit2->Text);
    с_v--;
 
    for (int i = 0; i <= mas.size() - 1; i++) {
        if (i == с_v)
            mas[i].color = ColorBox1->Selected;
    }
    pererisovka();
}
 
// ---------------------------------------------------------------------------
// раскидать точки
void __fastcall TForm1::Button6Click(TObject *Sender) {
    for (int i = 0; i <= mas.size() - 1; i++) {
        mas[i].randXY();
    }
    pererisovka();
}
 
// ---------------------------------------------------------------------------
// изменить размер ребра
void __fastcall TForm1::Button7Click(TObject *Sender) {
    int r_r = StrToInt(Edit6->Text); // размер
    int v1 = StrToInt(Edit4->Text);
    int v2 = StrToInt(Edit5->Text);
    v1--;
    v2--;
    for (int i = 0; i <= mas2.size() - 1; i++) {
        if ((mas2[i].ot1 == v1 && mas2[i].do2 == v2) ||
            (mas2[i].ot1 == v2 && mas2[i].do2 == v1)) {
            mas2[i].razmer = r_r;
        }
    }
    pererisovka();
}
 
// ---------------------------------------------------------------------------
// изменить цвет ребра
void __fastcall TForm1::Button8Click(TObject *Sender) {
    int v1 = StrToInt(Edit4->Text);
    int v2 = StrToInt(Edit5->Text);
    v1--;
    v2--;
    for (int i = 0; i <= mas2.size() - 1; i++) {
        if ((mas2[i].ot1 == v1 && mas2[i].do2 == v2) ||
            (mas2[i].ot1 == v2 && mas2[i].do2 == v1)) {
            mas2[i].color = ColorBox2->Selected;
        }
    }
    pererisovka();
}
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::Button9Click(TObject *Sender) {
    numev = 4; // режим перетаскивания
}
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::Image1MouseMove(TObject *Sender, TShiftState Shift,
    int X, int Y) {
 
    // для перемещения
    if (end == false) {
        viX0 = X;
        viY0 = Y;
        end = true;
    }
 
    if (fMove) {
        for (int i = 0; i < kv; i++) {
            if ((X > (mas[i].x - 5)) && (X < (mas[i].x + 5))) {
                if ((Y > (mas[i].y - 5)) && (Y < (mas[i].y + 5))) {
                    if (end == true) {
                        mas[i].x = viX0;
                        mas[i].y = viY0;
                        end = false;
                        pererisovka();
                    }
 
                }
            }
        }
    }
 
}
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::Image1MouseUp(TObject *Sender, TMouseButton Button,
    TShiftState Shift, int X, int Y) {
    fMove = false; // перестали тащить вершину
}
 
// ---------------------------------------------------------------------------
// увеличить в н раз ребро
void __fastcall TForm1::Button10Click(TObject *Sender) {
    int r2 = StrToInt(Edit3->Text);
    int v1 = StrToInt(Edit4->Text);
    int v2 = StrToInt(Edit5->Text);
    v1--;
    v2--;
    for (int i = 0; i <= mas2.size() - 1; i++) {
        if ((mas2[i].ot1 == v1 && mas2[i].do2 == v2) ||
            (mas2[i].ot1 == v2 && mas2[i].do2 == v1)) {
            mas2[i].razmer_plus(r2);
        }
    }
    pererisovka();
}
 
// ---------------------------------------------------------------------------
// уменьшить в н раз
void __fastcall TForm1::Button11Click(TObject *Sender) {
    int r = StrToInt(Edit7->Text);
    int v1 = StrToInt(Edit4->Text);
    int v2 = StrToInt(Edit5->Text);
    v1--;
    v2--;
    for (int i = 0; i <= mas2.size() - 1; i++) {
        if ((mas2[i].ot1 == v1 && mas2[i].do2 == v2) ||
            (mas2[i].ot1 == v2 && mas2[i].do2 == v1)) {
            mas2[i].razmer_minus(r);
        }
    }
    pererisovka();
}
 
// ---------------------------------------------------------------------------
// увеличить
void __fastcall TForm1::Button12Click(TObject *Sender) {
    int n_v = StrToInt(Edit2->Text);
    n_v--;
    int ra = StrToInt(Edit8->Text);
    for (int i = 0; i <= mas.size() - 1; i++) {
        if (i == n_v) {
            mas[i].razmer_plus(ra);
        }
 
    }
    pererisovka();
}
 
// ---------------------------------------------------------------------------
// уменьшить вершину
void __fastcall TForm1::Button13Click(TObject *Sender) {
    int m_v = StrToInt(Edit2->Text);
    m_v--;
    int ra = StrToInt(Edit9->Text);
    for (int i = 0; i <= mas.size() - 1; i++) {
        if (i == m_v) {
            mas[i].razmer_minus(ra);
        }
    }
    pererisovka();
}
// ---------------------------------------------------------------------------

class rebro; // прототип класса
 
class vershina {
public:
 
    int x, y;
    int razmer_ver;
    int color;
    std::vector< rebro * > rebra; // массив указателей на ребра
 
    void randXY() {
        x = rand() % 400;
        y = rand() % 300;
    }
 
    void razmer_plus(int tg) {
        razmer_ver = razmer_ver * tg;
    }
 
    void razmer_minus(int fd) {
        razmer_ver = razmer_ver / fd;
    }
};
 
 
 
class rebro {
public:
    int razmer;
    int ot1;
    int do2;
    vershina * first_v, * second_v; // два указателя на вершины
 
    void razmer_plus(int t) {
        razmer = razmer * t;
    }
 
    void razmer_minus(int kl) {
        razmer = razmer / kl;
    }
};

        rebro as;
        as.razmer = 10;
        as.ot1 = i;
        as.do2 = line;
        as.color = 000;
        as.first_v=i;           // ошибки
        as.second_v=line;   // i и line номер вершин с которыми связано ребро
        mas2.push_back(as); // добавляет элемент в конец массива

std::vector<vershina>mas; // массив классов вершин
std::vector<rebro>mas2; // массив классов ребер

void pererisovka() {
    // очистка компонента
    Form1->Image1->Picture->Bitmap->FreeImage();
    Form1->Image1->Picture->Bitmap = NULL;
 
    // рисуем линии
    for (int i = 0; i < kv; i++)
        for (int j = 0; j < kv; j++) {
            if (matrix[i][j] == 1) {
                for (int g = 0; g < kv; g++) { // по классам ребер
                    if ((mas2[g].ot1 == i && mas2[g].do2 == j) ||
                        (mas2[g].ot1 == j && mas2[g].do2 == i)) {
                       // как вытащить координаты?
                    }
                }
            }
        }
 
    // рисуем точки
    int io = 1;
    for (int i = 0; i <= mas.size() - 1; i++) {
       // и тут координаты вершин
    }
 
}

std::vector< rebro * > mas2;
 
        rebro *as = new rebro( );
        as->razmer = 10;
        as->ot1 = i; // эти два параметра уже в принципе ни к чему
        as->do2 = line;
        as->color = 000;
        as->first_v = mas[i];          
        as->second_v = mas[line];   // i и line номер вершин с которыми связано ребро
        mas2.push_back( as ); 
 
if ( mas2[0]->ot1 == 1 )
{
// ...
}
 
// в конце не забываем память освобождать:
for( std::vector< rebro * >::iterator it = mas2.begin(), end = mas2.end(); it != end; ++it )
{
    delete *it;
}
mas2.clear();
// то же самое для вектора с вершинами

        as->first_v = mas[i];

[BCC32 Error] Unit1.cpp(259): E2034 Cannot convert 'vershina &' to 'vershina *'

std::vector<vershina *>mas;