How to remove the vector and subsitute with normal function

[4everct01]

I wonder if anyone can help me or guide me the way to remove the vector and subsitute with normal function instead of using the vector reference?

/*=================main.cpp===========================*/
#include <iostream>
#include "Solitaire.h"

using namespace std;

void HandleMove(Solitaire& game);
void HandleMoveToAnswer(Solitaire& game);
void ClearScreen();

int main(int argc, char** argv)
{    
    Solitaire game = Solitaire();
    game.PrintAllDetails();
    
    bool running = true;
    do{
        char option = ' ';
        cout<<endl<<endl;
        cout<<"1. move card between rows";        
        cout<<"\n2. move to answers";
        cout<<"\n3. deal";
        cout<<"\n0. quit";
        cout<<"\nEnter option:";
        cin >> option;
        
        /* 48 - 55 ascii code is 0 - 7 */

        if(game.GameCompleted())
        {
            ClearScreen();
            cout<<"\n\n\n\t\t\t CONGRATULATIONS YOU WON!!!\n\n";
            cin.get();
            running = false;
        }

        else
        {
            switch((int)option)
            {
            case 48:
                running = false;
                break;
            case 49:
                HandleMove(game);
                break;        
            case 50:
                HandleMoveToAnswer(game);
                break;        
            case 51:
                game.Deal(3);
                break;
            default:
                cout<<"\ninvalid option";
                cin.ignore(80,'\n');
                break;
            }
            ClearScreen();
            game.PrintAllDetails();            
        }

    }while(running);
    
    return 0;
}

void HandleMove(Solitaire& game)
{
    char from = '0' ,to = '0';
    cout<<endl <<endl;
    cout<<"From (7 for deck):";
    cin >> from;
    cout<< "To: ";
    cin>> to;

    if( ((int)from >= 48 && (int)from <= 55) &&
        ((int)from >= 48 && (int)to <= 54) )

    {
        game.MakeMoveRowToRow((int)from - 48,(int)to - 48);
    }

    else
    {
        cout<<"invalid input";
        cin.get();
        cin.get();
    }
    
}

void HandleMoveToAnswer(Solitaire& game)
{
    char from = 0;
    cout<<endl <<endl;
    cout<< "From (7 for deck): ";
    cin>> from;
    
    if((int)from >= 48 && (int)from <= 55)
        game.MakeSuitMove((int)from - 48);
    
    else
    {
        cout<<"invalid input";
        cin.get();
        cin.get();
    }
    
}

void ClearScreen()
{
#ifdef __linux__ 
    system("clear");
#elif _WIN32
    system("cls");
#endif
}

/*=============================================*/
/*=================Card.h=======================*/
#pragma once
#include <iostream>

#ifdef _WIN32
#include<windows.h>
const static int BLACK = 0;
const static int BLUE = 9;
const static int RED = 12;
const static int WHITE = 15;
#elif __linux__
#include "stdlib.h"
#endif

class Card
{
public:
    Card(void);
    Card(char rank,char suit);    
    ~Card(void);

    void Flip();
    bool GetIsFaceUp();

    int GetSolitaireValue();
    char GetCardSuit();
    char GetCardRank();
    
    friend std::ostream & operator<< (std::ostream & os, Card& c); 
    
    /* 
       Used to navigate up and
       down the cards in a row
     */
    Card* parent;
    Card* child;
    
private:
    char rank;
    char suit;
    bool isFaceUp;

};

/*=============================================*/
/*====================Card.cpp===================*/
#include "Card.h"

Card::Card(void)
{
}

Card::Card(char r, char s)
:rank(r)
,suit(s)
,isFaceUp(false)
,child(NULL)
,parent(NULL)
{
}

Card::~Card(void)
{
}

void Card::Flip()
{
    isFaceUp = !isFaceUp;
}

bool Card::GetIsFaceUp()
{
    return isFaceUp;
}

char Card::GetCardSuit()
{
    return suit;
}

char Card::GetCardRank()
{
    return rank;
}

int Card::GetSolitaireValue()
{
    if(rank == 'A')
        return 1;
    else if(rank == 'T')
        return 10;
    else if(rank == 'J')
        return 11;
    else if(rank == 'Q')
        return 12;
    else if(rank == 'K')
        return 13;
    else
    {
        char c[] = {rank, '\0'};
        return atoi(c);
    }
}

std::ostream & operator<< (std::ostream & os, Card& c)
{

#ifdef _WIN32
    HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);

    if(c.suit == 'c' || c.suit == 's')
        SetConsoleTextAttribute(handle, BLUE);
    else
        SetConsoleTextAttribute(handle,RED);

    os<< c.suit << c.rank;
    SetConsoleTextAttribute(handle,WHITE);

#elif __linux__

    if(c.suit == 'c' || c.suit == 's')
        os<<"\033[22;34m";    
    else
        os<<"\033[22;31m";
    os<< c.suit << c.rank;
    os<<"\033[22;30m";

#endif

    return os;
}

/*=============================================*/
/*====================Deck.h====================*/
#pragma once
#include "Card.h"
#include <ctime>
#include <iostream>
#include "TableCard.h"

const static int RANK_SIZE = 13;
const static int SUIT_SIZE = 4;
const static char RANKS[] = {'A','2','3','4','5','6','7','8','9','T','J','Q','K'};
const static char SUITS[] = {'h','d','s','c'};


class Deck
{
public:
    Deck(void);
    ~Deck(void);

    void Populate(void);
    void Shuffle(void);
    void PrintDeck(void);

    void PopulateVector(TableCard& aDeck);
    
private:
    Card _deck[52];
    int currentIndex;
};

/*==============================================*/
/*====================Deck.cpp====================*/
#include "Deck.h"

Deck::Deck(void)
:currentIndex(0)
{
    srand((unsigned)time(0));
    Populate();
}


Deck::~Deck(void)
{
}

void Deck::Populate()
{
    int index = 0;
    for(int i=0; i<SUIT_SIZE; i++)
    {
        for(int j=0; j<RANK_SIZE;j++)
        {
            _deck[index] = Card(RANKS[j],SUITS[i]);
            index++;
        }
    }
}

void Deck::Shuffle()
{
    int max = SUIT_SIZE * RANK_SIZE;
    for(int i=0; i<max-1; i++)
    {
        int randNum = rand() % 52;
        std::swap(_deck[i],_deck[randNum]);        
    }
    
}

void Deck::PrintDeck(void)
{
    int max = SUIT_SIZE * RANK_SIZE;
    for(int i=0; i<max; i++)
    {
        if(i %13 == 0)
            std::cout<< '\n' <<'\n';
        std::cout<< _deck[i] << " ";
    }
}

void Deck::PopulateVector(TableCard& aDeck)
{
    int max = SUIT_SIZE * RANK_SIZE;
    aDeck.Clear();
    for(int i=0; i<max; i++)
        aDeck.PushValueCopy(_deck[i]);
}
/*===============================================*/
/*====================TableCard.h===================*/
#pragma once
#include "Card.h"
#include <vector>

class TableCard
{
public:
    TableCard(int maxSize);
    ~TableCard(void);

    Card& operator[](int index);
    bool Push(Card& card);    
    bool PushValueCopy(Card card);    
    int Size();
    bool empty();
    Card& top(void);
    
    bool RemoveAt(int index);
    bool Pop();
    void Clear();    


    static void MoveBetween(TableCard& from, TableCard& to);
    

private:
    int _maxSize;
    int _size;
    std::vector<Card*> _cards;

};
/*=============================================*/
/*====================TableCard.cpp================*/
#include "TableCard.h"

TableCard::TableCard(int maxSize)
:_size(0)
,_maxSize(maxSize)
{    
    _cards.resize(maxSize);
}

TableCard::~TableCard(void)
{
}

bool TableCard::Push(Card& card)
{
    if(_size < _maxSize)
    {
        _cards[_size] = &card;
        _size++;
        return true;
    }
    return false;
}

bool TableCard::PushValueCopy(Card card)
{
    if(_size < _maxSize);
    {
        _cards[_size] = new Card(card);
        _size++;
        return true;
    }
    return false;
}

void TableCard::Clear()
{
    for(int i=0; i<_size; i++)
        _cards[i] = NULL;
    
    _size = 0;
}

bool TableCard::empty()
{
    if(_size == 0)
        return true;
    return false;
}

Card& TableCard::top(void)
{
    if(_size > 0)
        return *_cards[_size-1];
}

bool TableCard::RemoveAt(int index)
{
    if(index >= 0 && index < _maxSize)
    {
        _cards[index] = NULL;
        _size--;
        return true;
    }
    return false;
}

int TableCard::Size()
{
    return _size;
}


bool TableCard::Pop()
{
    if(_size > 0)
    {
        _cards[_size - 1] = NULL;
        _size--;
        return true;
    }
    return false;
}

Card& TableCard::operator[](int index)
{
    if(index >= 0 && index <= _size)
        return *_cards[index];
}

void TableCard::MoveBetween(TableCard& from, TableCard& to)
{
    to.Push(from.top());
    from.Pop();
}

/*=============================================*/
/*====================Solitaire.h==================*/
#pragma once

#include <iostream>
#include <vector>

#include "Deck.h"
#include "Card.h"
#include "TableCard.h"

const static int TABLE_SIZE = 7;

class Solitaire
{
public:
    Solitaire(void);
    ~Solitaire(void);

    void PopulateTable(void);
    void Deal(int numToDeal=1);
    
    
    /* Functions for validating and moving cards  */
    void MakeSuitMove(int from);
    void MakeMoveBetweenRows(int from, int to);
    void MakeMoveDeckToRow(int to);
    void MakeMoveRowToRow(int from, int to);
    bool ValidMove(int from, int to);    
    bool ValidRowToRowMove(Card* fromCard, int to);
    bool ValidSuitMove(int from);

    /* Checks to see if all answer sections full */
    bool GameCompleted();
    
    /* Functions for printing card details */
    void PrintAllDetails(void);
    void PrintSuitDetails(void);
    void PrintDeckDetails(void);

private:
    
    TableCard _deck;
    TableCard _discardedCards;            
    std::vector<TableCard> _tableCards;
    
    //Destination of cards. When all filled player wins
    std::vector<TableCard> _suitCards;


};
/*==============================================*/
/*====================Solitaire.cpp=================*/
#include "Solitaire.h"
using namespace std;
Solitaire::Solitaire(void)
:_deck(52)
,_discardedCards(52)
{
    //Uses the deck class to populate solitaire deck
    //Shuffle the deck to randomize 
    Deck deck = Deck();
    deck.Shuffle();    
    deck.PopulateVector(_deck);
        
    for(int i=0; i<TABLE_SIZE; i++)
    {
        TableCard tableCard = TableCard(20);
        _tableCards.push_back(tableCard);
    }
    
    //_suitCards.resize(4);
    for(int i=0; i<4; i++)
    {    
        TableCard suitCard = TableCard(13);
        _suitCards.push_back(suitCard);    
    }
    PopulateTable();
}

Solitaire::~Solitaire(void)
{
}

void Solitaire::PopulateTable(void)
{
    for(int i=0; i<TABLE_SIZE; i++)
    {        
        for(int j=0; j<TABLE_SIZE -i; j++)
        {    
            if(j == (TABLE_SIZE - i) - 1)
                _deck.top().Flip();

            _tableCards[j].Push(_deck.top());
            _deck.Pop();
        }
    }
}

void Solitaire::Deal(int numToDeal)
{
    int size = _deck.Size();
    for(int i=0; i<size; i++)
    {
        if(_deck.top().GetIsFaceUp())
        {
            _deck.top().Flip();
            _discardedCards.Push(_deck.top());
            _deck.Pop();
        }        
    }

    if(_deck.empty())
    {
        for(int i=_discardedCards.Size()-1; i>=0; i--)
            _deck.Push(_discardedCards[i]);            
        
        _discardedCards.Clear();
    }

    int index = 0;
    for(int i=0; i<numToDeal; i++)
    {
        index = _deck.Size() -i -1;
        if(index >= 0)
        {
            _deck[index].Flip();
        }
        else
            break;
    }
}

void Solitaire::PrintSuitDetails()
{
    cout<<"=============================================\n";
    for(int j=0; j<_suitCards.size(); j++)
    {
        switch(j)
        {
        case 0:
            cout<< "h :";
            break;
        case 1:
            cout<< "d :";
            break;
        case 2:
            cout<< "s :";
            break;
        case 3:
            cout<< "c :";
            break;
        }
        
        for(int i=0; i<_suitCards[j].Size(); i++)
        {
            if(&_suitCards[j][i] != NULL)
                cout<<_suitCards[j][i] << " ";
            else
                break;
        }
        cout<< endl;
    }
    cout<<"=============================================\n";
    cout<<endl;
}

void Solitaire::PrintDeckDetails()
{
    cout<<"--------------------------------------------\n";
    cout<<"|Deck: ";
    for(unsigned int i=0; i<_deck.Size(); i++)
    {        
        if(_deck[i].GetIsFaceUp())
            cout<<_deck[i] << " ";
        
    }
    cout<<"\n--------------------------------------------\n";
}

void Solitaire::PrintAllDetails()
{
    
    PrintDeckDetails();
    PrintSuitDetails();


    cout<< "| 6 | \t | 5 | \t | 4 | \t | 3 | \t | 2 | \t | 1 | \t | 0 |\n";
    cout<< "----- \t ----- \t ----- \t ----- \t ----- \t ----- \t -----\n";
    
    //Cannot be unsigned as number is always greater than or equal to 0 --
    int colMax = _tableCards.size();
    int rowMax = 0;
    for(int i=0; i<colMax; i++)
    {
        if(_tableCards[i].Size() > rowMax)
        {
            rowMax = _tableCards[i].Size();
        }
    }

    for(int i=0; i<rowMax; i++)
    {        
        for(int j=colMax-1; j>=0; j--)
        {    
            if(i >= _tableCards[j].Size())
            {
                cout<< " \t " ;
                continue;
            }
                    
            if(_tableCards[j][i].GetIsFaceUp())
                cout << "  "  << _tableCards[j][i] << " \t ";
            else
                cout << "  " <<(char)254 << " \t ";
        }
        cout<<endl;
    }
    cout<<endl<<endl;


    //SHOW DISCARDED CARDS
    /*cout<<"\nCards in the used pile: \n\n";
    for(unsigned int i=0; i<_discardedCards.Size(); i++)
        cout<<_discardedCards[i] << " ";
    cout<<endl<<endl;
    */
        //DISPLAYS CHILDREN AND PARENTS
    /*for(int i=0; i<_tableCards.size(); i++)
    {
        cout<< i << ": \n" ; 
        for(int j= 0; j< _tableCards[i].Size(); j++)
        {
            if(_tableCards[i][j].child != NULL)
            {
                cout<< _tableCards[i][j] << "'s child is " << *_tableCards[i][j].child << endl;
            }
            if(_tableCards[i][j].parent != NULL)
            {
                cout<< _tableCards[i][j] << "'s parent is " << *_tableCards[i][j].parent << endl;
            }
        }
    }*/

}

bool Solitaire::ValidMove(int from, int to)
{    

    //start move and end move the same
    if(from == to && from != 7)
        return false;

    Card* toCard;
    Card* fromCard;

    if(from == 7)
    {
        if(!_deck.empty())
        {
            if(!_deck.top().GetIsFaceUp())
            {
                return false;
            }
            else
            {
                fromCard = &_deck.top();
            }
        }
        else
        {
            return false;
        }
    }
    else
    {
        //if no card in moving from row not valid
        if(!_tableCards[from].empty())
            fromCard = &_tableCards[from].top();
        else
            return false;
    }

    if(!_tableCards[to].empty())
        toCard = &_tableCards[to].top();

    //move king to empty space
    if(_tableCards[to].empty())
    {        
        if(fromCard->GetCardRank() == 'K')
            return true;
        else
            return false;
    }

    else if(fromCard->GetSolitaireValue() == toCard->GetSolitaireValue()-1 )
    {
        int toColor = 0, fromColor = 0;
        if(toCard->GetCardSuit() == 'h' || toCard->GetCardSuit() == 'd')
            toColor = 0;
        else
            toColor = 1;
        if(fromCard->GetCardSuit() =='h' || fromCard->GetCardSuit() == 'd')
            fromColor = 0;
        else
            fromColor = 1;

        if(fromColor == toColor)
            return false;
        else
            return true;
    }    
    return false;
}

bool Solitaire::ValidSuitMove(int from)
{
    Card* fromCard;
    if(from == 7)
    {
        if(!_deck.empty())
        {
            if(!_deck.top().GetIsFaceUp())
            {
                return false;
            }
            else
            {
                fromCard = &_deck.top();
            }
        }
        else
        {
            return false;
        }
    }
    else
    {
        if(!_tableCards[from].empty())
            fromCard = &_tableCards[from].top();
        else
            return false;
    }


    char suit = fromCard->GetCardSuit();
    int moveIndex = 0;
    switch(suit)
    {
    case 'h':
        moveIndex = 0;
        break;
    case 'd':
        moveIndex =    1;
        break;
    case 's':
        moveIndex = 2;
        break;
    case 'c':
        moveIndex = 3;
        break;
    }

    if(fromCard->GetSolitaireValue() == 
            _suitCards[moveIndex].Size() + 1 )
    {
        if(!_suitCards[moveIndex].Size() == 0)
        {
            if(fromCard->parent != NULL)
                fromCard->parent->child = NULL;
            fromCard->parent = &_suitCards[moveIndex].top();
            _suitCards[moveIndex].top().child = fromCard;
            fromCard->child = NULL;

        }
        if(from != 7){
            TableCard::MoveBetween(_tableCards[from],_suitCards[moveIndex]);
            if(!_tableCards[from].empty())
            {
                if(!_tableCards[from].top().GetIsFaceUp())
                    _tableCards[from].top().Flip();
            }
        }
        else
        {
            _suitCards[moveIndex].Push(_deck.top());
            _deck.Pop();
        }
    }
            
    
    return false;    
}

void Solitaire::MakeSuitMove(int from)
{
    /* validSuit move also makes move */
    ValidSuitMove(from)    ;
}



void Solitaire::MakeMoveBetweenRows(int from, int to)
{
    if(ValidMove(from,to))
    {
        if(!_tableCards[to].empty())
            _tableCards[to].top().child = &_tableCards[from].top();
        
        if(_tableCards[from].top().GetCardRank() != 'K')
            _tableCards[from].top().parent = &_tableCards[to].top();

        TableCard::MoveBetween(_tableCards[from], _tableCards[to]);
                
        if(!_tableCards[from].empty())
            if(!_tableCards[from].top().GetIsFaceUp())
                _tableCards[from].top().Flip();
    }
}

void Solitaire::MakeMoveDeckToRow(int to)
{
    if(ValidMove(7 ,to))
    {
        if(!_tableCards[to].empty())
            _tableCards[to].top().child = &_deck.top();    
        if(_deck.top().GetCardRank() != 'K')
            _deck.top().parent = & _tableCards[to].top();
        
        _tableCards[to].Push(_deck.top());
        _deck.Pop();
            

    }
}

void Solitaire::MakeMoveRowToRow(int from, int to)
{
    if(from == 7)
    {    
        MakeMoveDeckToRow(to);
        return;
    }
    else if(_tableCards[from].Size() == 0)
        return;

    Card* fromCard;
    fromCard = &_tableCards[from].top();

    if(fromCard->parent == NULL)
        MakeMoveBetweenRows(from,to);
    else
    {
        int pos = _tableCards[from].Size()-1;
        bool checkParent = true;
        bool found = false;
        while(checkParent && !found)
        {                    
            if(ValidRowToRowMove(fromCard,to))
                found = true;
            else if(fromCard->parent == NULL)
                checkParent = false;
            else
            {
                fromCard = fromCard->parent;
                pos--;
            }
            
        }

        if(found)
        {
            bool hasChildren = true;
            if(fromCard->parent != NULL)
                    fromCard->parent->child = NULL;
            
            while(hasChildren)
            {    
                
                if(!_tableCards[to].empty())
                {
                    fromCard->parent = &_tableCards[to].top();
                    _tableCards[to].top().child = fromCard;
                }
                _tableCards[to].Push(*fromCard);

                _tableCards[from].RemoveAt(pos);
                fromCard = fromCard->child;
        
                                    
                pos++;
                if(fromCard == NULL)
                    hasChildren = false;
            }

        }

        if(!_tableCards[from].empty())
            if(!_tableCards[from].top().GetIsFaceUp())
                _tableCards[from].top().Flip();
    }
}

bool Solitaire::ValidRowToRowMove(Card* fromCard, int to)
{
    Card* toCard;    

    if(!_tableCards[to].empty())
        toCard = &_tableCards[to].top();

    //move king to empty space
    if(_tableCards[to].empty())
    {
        if(fromCard->GetCardRank() == 'K')
            return true;
        else
            return false;
    }
    
    else if(fromCard->GetSolitaireValue() == toCard->GetSolitaireValue()-1 )
    {
        int toColor = 0, fromColor = 0;
        if(toCard->GetCardSuit() == 'h' || toCard->GetCardSuit() == 'd')
            toColor = 0;
        else
            toColor = 1;
        if(fromCard->GetCardSuit() =='h' || fromCard->GetCardSuit() == 'd')
            fromColor = 0;
        else
            fromColor = 1;

        if(fromColor == toColor)
            return false;
        else
            return true;
    }    
    return false;

}

bool Solitaire::GameCompleted()
{
    for(int i=0; i<_suitCards.size(); i++)
        if(_suitCards[i].Size() < 13)
            return false;
    return true;
}
/*==============================================*/

[jonsca]

That is a lot of code to go through. You should whittle it down to compilable snippets of the source files in question.

[4everct01]

Ok here is the part i would like some exprt to guide me how to convert the vector to normal function. I tried to use

Card* _cards;

it shows the following error.

C:\Users\Huan\Desktop\DataStructure\Solitaire\TableCard.cpp:57: error: no match for 'operator=' in '*(((TableCard*)this)->TableCard::_cards + (+(((unsigned int)index) * 12u))) = 0'
C:\Users\Huan\Desktop\DataStructure\Solitaire\Card.h:13: note: candidates are: Card& Card::operator=(const Card&)
C:\Users\Huan\Desktop\DataStructure\Solitaire\TableCard.cpp: In member function `bool TableCard::Pop()':
C:\Users\Huan\Desktop\DataStructure\Solitaire\TableCard.cpp:73: error: no match for 'operator=' in '*((((TableCard*)this)->TableCard::_cards + ((Card*)(((unsigned int)((TableCard*)this)->TableCard::_size) * 12u))) - 12u) = 0'
C:\Users\Huan\Desktop\DataStructure\Solitaire\Card.h:13: note: candidates are: Card& Card::operator=(const Card&)
C:\Users\Huan\Desktop\DataStructure\Solitaire\TableCard.cpp: In member function `Card& TableCard::operator[](int)':
C:\Users\Huan\Desktop\DataStructure\Solitaire\TableCard.cpp:83: error: no match for 'operator*' in '**(((TableCard*)this)->TableCard::_cards + (+(((unsigned int)index) * 12u)))'

Here is the code for my small part =)

#pragma once
#include <iostream>
#include<windows.h>
const static int BLACK = 0;
const static int BLUE = 9;
const static int RED = 12;
const static int WHITE = 15;
#include "stdlib.h"

class Card
{
    public:
    Card();
    Card(char rank,char suit);
    ~Card();

    void Flip();
    bool GetIsFaceUp();

    int GetSolitaireValue();
    char GetCardSuit();
    char GetCardRank();

    friend std::ostream & operator<< (std::ostream & os, Card& c);

    /*
    Used to navigate up and
    down the cards in a row
    */
    Card* parent;
    Card* child;

    private:
    char rank;
    char suit;
    bool isFaceUp;

};
#endif

/*====================Card.cpp===================*/
#include "Card.h"

Card::Card(void){}
Card::Card(char r, char s) : rank(r), suit(s), isFaceUp(false), child(NULL), parent(NULL){}
Card::~Card(void){}

void Card::Flip()
{
    isFaceUp = !isFaceUp;
}

bool Card::GetIsFaceUp()
{
    return isFaceUp;
}

char Card::GetCardSuit()
{
    return suit;
}

char Card::GetCardRank()
{
return rank;
}

int Card::GetSolitaireValue()
{
    if(rank == 'A')
        return 1;
    else if(rank == 'T')
        return 10;
    else if(rank == 'J')
        return 11;
    else if(rank == 'Q')
        return 12;
    else if(rank == 'K')
        return 13;
    else
    {
        char c[] = {rank, '\0'};
        return atoi(c);
    }
}

std::ostream & operator<< (std::ostream & os, Card& c)
{

    HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);

    if(c.suit == char(6) || c.suit == char(5))
    SetConsoleTextAttribute(handle, BLUE);
    else
    SetConsoleTextAttribute(handle,RED);

    os<< c.suit << c.rank;
    SetConsoleTextAttribute(handle,WHITE);

    return os;
}

/*=============================================*/
/*====================TableCard.h===================*/
#pragma once
#include "Card.h"
#include <<strong class="highlight">vector</strong>>

class TableCard
{
public:
    TableCard(int maxSize);
    ~TableCard(void);

    Card& operator[](int index);
    bool Push(Card& card);    
    bool PushValueCopy(Card card);    
    int Size();
    bool empty();
    Card& top(void);
    
    bool RemoveAt(int index);
    bool Pop();
    void Clear();    


    static void MoveBetween(TableCard& from, TableCard& to);
    

private:
    int _maxSize;
    int _size;
    std::vector<Card*> _cards;

};
/*=============================================*/
/*====================TableCard.cpp================*/
#include "TableCard.h"

TableCard::TableCard(int maxSize)
:_size(0)
,_maxSize(maxSize)
{    
    _cards.resize(maxSize);
}

TableCard::~TableCard(void)
{
}

bool TableCard::Push(Card& card)
{
    if(_size < _maxSize)
    {
        _cards[_size] = &card;
        _size++;
        return true;
    }
    return false;
}

bool TableCard::PushValueCopy(Card card)
{
    if(_size < _maxSize);
    {
        _cards[_size] = new Card(card);
        _size++;
        return true;
    }
    return false;
}

void TableCard::Clear()
{
    for(int i=0; i<_size; i++)
        _cards[i] = NULL;
    
    _size = 0;
}

bool TableCard::empty()
{
    if(_size == 0)
        return true;
    return false;
}

Card& TableCard::top(void)
{
    if(_size > 0)
        return *_cards[_size-1];
}

bool TableCard::RemoveAt(int index)
{
    if(index >= 0 && index < _maxSize)
    {
        _cards[index] = NULL;
        _size--;
        return true;
    }
    return false;
}

int TableCard::Size()
{
    return _size;
}


bool TableCard::Pop()
{
    if(_size > 0)
    {
        _cards[_size - 1] = NULL;
        _size--;
        return true;
    }
    return false;
}

Card& TableCard::operator[](int index)
{
    if(index >= 0 && index <= _size)
        return *_cards[index];
}

void TableCard::MoveBetween(TableCard& from, TableCard& to)
{
    to.Push(from.top());
    from.Pop();
}
=====================================*/

[iamthwee]

I wonder if anyone can help me or guide me the way to remove the vector and subsitute with normal function instead of using the vector reference?

Why? Giving you the benefit of the doubt here, but typically when people ask this type of question it is because they've copied a bit of code from someone who is slightly more advanced then them and they want to pass it off as their own... More importantly, be able to explain it to their teachers if they get quizzed.

This might not be homework, and I could be completely wrong...Just saying.