Возврат vector из класса

class comb
{
private:
    TCanvas* img;
    int row;
    int col;
    int radius;
    TPoint start;
    cell** g;
public:
        ..................
    int getRow();
    int getCol();
    vector<int> getNeighbors();  // ошибки E2303 Type name expected  и  E2139 Declaration missing ;
//      void (vector<int>& nbrs);     // так тоже не работоает

#include <vector>
 
class ....
{
    std::vector<int> getNeighbors();
 
}

//---------------------------------------------------------------------------
 
#ifndef beecellH
#define beecellH
 
//#include <System.Classes.hpp>
//#include <Vcl.Controls.hpp>
//#include <Vcl.StdCtrls.hpp>
//#include <Vcl.Forms.hpp>
#include <Vcl.ExtCtrls.hpp>
#include <vector>
 
struct pnt
{
    int x;
    int y;
    pnt(): x(0), y(0) {};
    pnt(int _x, int _y): x(_x), y(_y) {}
};
 
class cell
{
private:
    TPoint O;
    int r;
    int borderWidth;
    TColor borderColor;
    TColor fillColor;
    TCanvas* parent;
public:
    cell();
    cell(TCanvas* par, int _x=0, int _y=0 ,int _r=0, TColor bC=clBlack, TColor fC=clWhite, int bW=1);
    void setParent(TCanvas*);
    void setCoord(TPoint);
    void setCoord(int,int);
    void setRadius(int);
    void setBorderColor(TColor);
    void setBorderWidth(int);
    void setFillColor(TColor);
    void draw();
    void ShowText(UnicodeString);
    TPoint pointCoord(int);
};
 
class comb
{
private:
    TCanvas* img;
    int row;
    int col;
    int radius;
    TPoint start;
    cell** g;
public:
    comb(TCanvas* par, int r, int c, TPoint O, int _rad);
    ~comb();
    void paint();
    void draw(int,int);
    void drawColor(int,int,TColor);
    TPoint getCoord(int,int);
    cell& operator()(int,int);
    bool inBounds(int,int);
    bool inBounds(TPoint);
    int getRow();
    int getCol();
    vector<int> getNeighbors();
};
 
//---------------------------------------------------------------------------
#endif

//---------------------------------------------------------------------------
#pragma hdrstop
 
#include "beecell.h"
//---------------------------------------------------------------------------
 
/*
    cell();
    cell(TCanvas par, int x=0,int y=0,int r=0, TColor bC=clBlack, TColor fC=clWhite, int bW=1);
    setParent(TCanvas*);
    setCoord(int,int);
    setRadius(int);
    setBorderColor(TColor);
    setFillColor(TColor);
    draw();
*/
 
const double k=0.866;
 
cell::cell()
{
    parent = NULL;
    TPoint _O(0,0);
    O = _O;
    r = 0;
    borderWidth = 1;
    borderColor = clBlack;
    fillColor = clWhite;
}
 
cell::cell(TCanvas* par, int _x, int _y,int _r, TColor bC, TColor fC, int bW)
{
    parent = par;
    TPoint _O(_x,_y);
    O = _O;
    r = 0;
    borderWidth = 1;
    borderColor = clBlack;
    fillColor = clYellow;
}
 
void cell::setParent(TCanvas* can)
{
    parent = can;
}
 
void cell::setCoord(int _x, int _y)
{
    O.x = _x;
    O.y = _y;
}
 
void cell::setCoord(TPoint P)
{
    O = P;
}
 
void cell::setRadius(int _r)
{
    r = _r;
}
 
void cell::setBorderColor(TColor col)
{
    borderColor = col;
}
 
void cell::setFillColor(TColor col)
{
    fillColor = col;
}
 
void cell::setBorderWidth(int bw)
{
    borderWidth = bw;
}
 
void cell::draw()
{
    TPoint cl[7];
    parent->Pen->Width = borderWidth;
    parent->Pen->Color = borderColor;
    parent->Brush->Color = fillColor;
 
    cl[0] = TPoint(O.x,O.y);
    cl[1] = TPoint(O.x+r/2, (int)(O.y+r*k));
    cl[2] = TPoint(O.x+3*r/2, (int)(O.y+r*k));
    cl[3] = TPoint(O.x+2*r, O.y);
    cl[4] = TPoint(O.x+3*r/2, (int)(O.y-r*k));
    cl[5] = TPoint(O.x+r/2, (int)(O.y-r*k));
    cl[6] = TPoint(O.x, O.y);
    parent->Polygon(cl,6);
}
 
TPoint cell::pointCoord(int n)
{
    switch (n) {
        case 0: return O; break;
        case 5: return TPoint(O.x+r/2, (int)(O.y+r*k)); break;
        case 4: return TPoint(O.x+3*r/2, (int)(O.y+r*k)); break;
        case 3: return TPoint(O.x+2*r, O.y); break;
        case 2: return TPoint(O.x+3*r/2, (int)(O.y-r*k)); break;
        case 1: return TPoint(O.x+r/2, (int)(O.y-r*k)); break;
    default:
        ;
    }
}
 
void cell::ShowText(UnicodeString s)
{
    parent->TextOutW((O.X+r-parent->TextWidth(s)/2),(O.Y-parent->TextHeight(s)/2),s);
}
 
//======================= C O M B ==============================================
 
comb::comb(TCanvas* par, int r, int c, TPoint O, int _rad)
{
    img = par;
    row = r;
    col = c;
    start = O;
    radius = _rad;
    g = new cell*[row];
    for (int i = 0; i < row; i++) {
        g[i] = new cell[col];
        for (int j = 0; j < col; j++) {
            g[i][j].setParent(img);
            //if (j==0)
            //g[i][j].setCoord(start.X,start.Y+(int)(i*2*k*r));
            //else
            g[i][j].setCoord(start.X+(int)(j*3*radius/2),
                    start.Y+(int)(i*2*k*radius)-(int)(j%2*radius*k));
            g[i][j].setRadius(radius);
            g[i][j].setBorderWidth(3);
        }
    }
}
 
void comb::draw(int r, int c)
{
    g[r][c].draw();
}
 
void comb::drawColor(int r, int c, TColor fc)
{
    g[r][c].setFillColor(fc);
    g[r][c].draw();
}
 
comb::~comb()
{
    for (int i = 0; i < row; i++) {
        delete [] g[i];
    }
    delete [] g;
}
 
void comb::paint()
{
    for(int i=0;i<row;i++)
    for(int j=0;j<col;j++)
        draw(i,j);
}
 
TPoint comb::getCoord(int X, int Y)
{
    int I = floor((Y-start.Y)/(k*radius)+2);
    int J = floor(((X-start.X)*cos(-M_PI/6)-(Y-start.Y)*sin(-M_PI/6))/(k*radius));
    int K = floor(((X-start.X)*cos(M_PI/6)-(Y-start.Y)*sin(M_PI/6))/(k*radius));
 
    int YY=(I-1)/2;
    if (I&&I%2==0) {
        if ((J-I/2)%3==1 && (K+I/2)%3==2) YY++;
        if ((J-I/2)%3==1 && (K+I/2)%3==0) YY++;
        if ((J-I/2)%3==2 && (K+I/2)%3==0) YY++;
    }
 
    int XX=-1;
    if ((K+YY)%3!=2)
    {
        XX=(K+YY)/3*2;
        if ((J-I/2)%3==1 && (K+I/2)%3==0) XX--;
        if ((J-I/2)%3==2 && (K+I/2)%3==0) XX--;
    }
    else XX = (K+YY-2)/3*2+1;
 
    return TPoint(XX,YY);
 
}
 
bool comb::inBounds(int ro, int co)
{
    return (ro<row && co<col);
}
 
bool comb::inBounds(TPoint P)
{
    return (P.Y<row && P.X<col);
}
 
cell& comb::operator()(int index, int jndex)
{
    if (index<row && jndex<col)
        return g[index][jndex];
}
 
int comb::getRow()
{
    return row;
}
 
int comb::getCol()
{
    return col;
}
 
/*
vector<int> comb::getNeighbors()
{
 
}
//*/
#pragma package(smart_init)

std::vector<int> getNeighbors();

std::vector<int> getNeighbors();