i made a vector class "MyVector" inherited from a base class "arrayList" which is derived from a base class linearlist.

whenever i compile i get a fatal error:

LINK : fatal error LNK1561: entry point must be defined

// abstract class linearList
// abstract data type specification for linear list data structure
// all methods are pure virtual functions

#ifndef linearList_
#define linearList_
#include <iostream>

using namespace std;

template<class T>
class linearList 
{
   public:
      virtual ~linearList() {};
      virtual bool empty() const = 0;
                  // return true iff list is empty
      virtual int size() const = 0;
                  // return number of elements in list
      virtual T& get(int theIndex) const = 0;
                  // return element whose index is theIndex
      virtual int indexOf(const T& theElement) const = 0;
                  // return index of first occurence of theElement
      virtual void erase(int theIndex) = 0;
                  // remove the element whose index is theIndex
      virtual void insert(int theIndex, const T& theElement) = 0;
                  // insert theElement so that its index is theIndex
      virtual void output(ostream& out) const = 0;
                  // insert list into stream out
};
#endif
// array implementation of a linear list
// derives from abstract class linearList just to make sure
// all methods of the ADT are implemented
// USES STL ALGORITHMS TO SIMPLIFY CODE

#ifndef arrayList_
#define arrayList_

#include<iostream>
#include<sstream>
#include<string>
#include<algorithm>
#include "linearList.h"
#include "myExceptions.h"
#include "changeLength1D.h"

using namespace std;

template<class T>
class arrayList : public linearList<T> 
{
   public:
      // constructor, copy constructor and destructor
      arrayList(int initialCapacity = 10);
      arrayList(const arrayList<T>&);
      ~arrayList() {delete [] element;}

      // ADT methods
      bool empty() const {return listSize == 0;}
      int size() const {return listSize;}
      T& get(int theIndex) const;
      int indexOf(const T& theElement) const;
      void erase(int theIndex);
      void insert(int theIndex, const T& theElement);
      void output(ostream& out) const;

      // additional method
      int capacity() const {return arrayLength;}

   protected:
      void checkIndex(int theIndex) const;
            // throw illegalIndex if theIndex invalid
      T* element;            // 1D array to hold list elements
      int arrayLength;       // capacity of the 1D array
      int listSize;          // number of elements in list
};

template<class T>
arrayList<T>::arrayList(int initialCapacity)
{// Constructor.
   if (initialCapacity < 1)
   {ostringstream s;
    s << "Initial capacity = " << initialCapacity << " Must be > 0";
    throw illegalParameterValue(s.str());
   }
   arrayLength = initialCapacity;
   element = new T[arrayLength];
   listSize = 0;
}

template<class T>
arrayList<T>::arrayList(const arrayList<T>& theList)
{// Copy constructor.
   arrayLength = theList.arrayLength;
   listSize = theList.listSize;
   element = new T[arrayLength];
   copy(theList.element, theList.element + listSize, element);
}

template<class T>
void arrayList<T>::checkIndex(int theIndex) const
{// Verify that theIndex is between 0 and listSize - 1.
   if (theIndex < 0 || theIndex >= listSize)
   {ostringstream s;
    s << "index = " << theIndex << " size = " << listSize;
    throw illegalIndex(s.str());
   }

}

template<class T>
T& arrayList<T>::get(int theIndex) const
{// Return element whose index is theIndex.
 // Throw illegalIndex exception if no such element.
   checkIndex(theIndex);
   return element[theIndex];
}

template<class T>
int arrayList<T>::indexOf(const T& theElement) const
{// Return index of first occurrence of theElement.
 // Return -1 if theElement not in list.

   // search for theElement
   int theIndex = (int) (find(element, element + listSize, theElement)
                         - element);

   // check if theElement was found
   if (theIndex == listSize)
     // not found
     return -1;
   else return theIndex;
 }

template<class T>
void arrayList<T>::erase(int theIndex)
{// Delete the element whose index is theIndex.
 // Throw illegalIndex exception if no such element.
   checkIndex(theIndex);

   // valid index, shift elements with higher index
   copy(element + theIndex + 1, element + listSize,
                                element + theIndex);

   element[--listSize].~T(); // invoke destructor
}

template<class T>
void arrayList<T>::insert(int theIndex, const T& theElement)
{// Insert theElement so that its index is theIndex.
   if (theIndex < 0 || theIndex > listSize)
   {// invalid index
      ostringstream s;
      s << "index = " << theIndex << " size = " << listSize;
      throw illegalIndex(s.str());
   }

   // valid index, make sure we have space
   if (listSize == arrayLength)
      {// no space, double capacity
         changeLength1D(element, arrayLength, 2 * arrayLength);
         arrayLength *= 2;
      }

   // shift elements right one position
   copy_backward(element + theIndex, element + listSize,
                 element + listSize + 1);

   element[theIndex] = theElement;

   listSize++;
}

template<class T>
void arrayList<T>::output(ostream& out) const
{// Put the list into the stream out.
   copy(element, element + listSize, ostream_iterator<T>(cout, "  "));
}

// overload <<
template <class T>
ostream& operator<<(ostream& out, const arrayList<T>& x)
   {x.output(out); return out;}

#endif
#ifndef MYVECTOR_H
#define MYVECTOR_H

#include <iostream>
//#include<vector>
#include "arrayList.h"
#include "changeLength1D.h"

using namespace std;

template <class T>
class MyVector: public arrayList<T>
{
protected:
	

public:

	MyVector();
	MyVector(int n);
	MyVector(const MyVector<T> &);
	int size();
	int capacity();
	T&at(int n);
	T &operator[](int n);
	void erase(int n);
	void clear();
	void push_back(const T &item);
	void pop_back();
	bool empty();

};


#endif
#include "MyVector.h"


template <class T>
MyVector<T>::MyVector():arrayList()
{

}

template < class T>
MyVector<T>::MyVector(int length):arrayList(length)
{

}

template <class T>  
MyVector<T>::MyVector(const MyVector<T>& myList)
{
	element=new T[mylist.element];
}


template <class T>
int MyVector<T>::size()
{
	return element->size();
}


template <class T>
int MyVector<T>::capacity()
{
	return arrayLength;
}


template <class T>
T& MyVector<T>::at(int n)
{
	return element->get(int n);
}

template <class T>
void MyVector<T>::erase(int n)
{
	element->erase(n);

	if(listSize/arrayLength < 1/2)
	{
		int temp=3/4(elem->capacity());
		T *newvect =new T[temp];
		copy(element,element+listSize,newVect);

		delete element[];
		element= newVect;
		arrayLength = temp;
	}
}

 template <class T>
bool MyVector<T>::empty()
{
	return element->empty();
}


template <class T>
void MyVector<T>::clear()
{
	delete element[];
	
	arrayLength=10;
	listSize=0;
}

template<class T>
void MyVector<T>::push_back(const T &item)
{
	if(arrayList==ListSize)
	{
		T *newvect = new T[2*arrayLength];
		copy(element,element+ listSize,newvect)

			delete element[];
		element=newvect;
		arrayLength=2*arrayLength;
	}
	
	item.insert(listSize-1,item);
}

template < class T>
void MyVector<T>::pop_back()
{
	element->erase(listSize-1);

	
	if(listSize/arrayLength < 1/2)
	{
		int temp=3/4(elem->capacity());
		T *newvect =new T[temp];
		copy(element,element+listSize,newVect);

		delete element[];
		element= newVect;
		arrayLength = temp;
	}
}
// change the length of an array

#ifndef changeLength1D_
#define changeLength1D_

#include "myExceptions.h"

using namespace std;

template<class T>
void changeLength1D(T*& a, int oldLength, int newLength)
{
   if (newLength < 0)
      throw illegalParameterValue("new length must be >= 0");

   T* temp = new T[newLength];              // new array
   int number = min(oldLength, newLength);  // number to copy
   copy(a, a + number, temp);
   delete [] a;                             // deallocate old memory
   a = temp;
}

#endif

i have one more class included

// exception classes for various error types

#ifndef myExceptions_
#define myExceptions_
#include <string>

using namespace std;

// illegal parameter value
class illegalParameterValue 
{
   public:
      illegalParameterValue(string theMessage = "Illegal parameter value")
            {message = theMessage;}
      void outputMessage() {cout << message << endl;}
   private:
      string message;
};

// illegal input data
class illegalInputData 
{
   public:
      illegalInputData(string theMessage = "Illegal data input")
            {message = theMessage;}
      void outputMessage() {cout << message << endl;}
   private:
      string message;
};

// illegal index
class illegalIndex 
{
   public:
      illegalIndex(string theMessage = "Illegal index")
            {message = theMessage;}
      void outputMessage() {cout << message << endl;}
   private:
      string message;
};

// matrix index out of bounds
class matrixIndexOutOfBounds 
{
   public:
      matrixIndexOutOfBounds
            (string theMessage = "Matrix index out of bounds")
            {message = theMessage;}
      void outputMessage() {cout << message << endl;}
   private:
      string message;
};

// matrix size mismatch
class matrixSizeMismatch 
{
   public:
      matrixSizeMismatch(string theMessage = 
                   "The size of the two matrics doesn't match")
            {message = theMessage;}
      void outputMessage() {cout << message << endl;}
   private:
      string message;
};

// stack is empty
class stackEmpty
{
   public:
      stackEmpty(string theMessage = 
                   "Invalid operation on empty stack")
            {message = theMessage;}
      void outputMessage() {cout << message << endl;}
   private:
      string message;
};

// queue is empty
class queueEmpty
{
   public:
      queueEmpty(string theMessage = 
                   "Invalid operation on empty queue")
            {message = theMessage;}
      void outputMessage() {cout << message << endl;}
   private:
      string message;
};

// hash table is full
class hashTableFull
{
   public:
      hashTableFull(string theMessage = 
                   "The hash table is full")
            {message = theMessage;}
      void outputMessage() {cout << message << endl;}
   private:
      string message;
};

// edge weight undefined
class undefinedEdgeWeight
{
   public:
      undefinedEdgeWeight(string theMessage = 
                   "No edge weights defined")
            {message = theMessage;}
      void outputMessage() {cout << message << endl;}
   private:
      string message;
};

// method undefined
class undefinedMethod
{
   public:
      undefinedMethod(string theMessage = 
                   "This method is undefined")
            {message = theMessage;}
      void outputMessage() {cout << message << endl;}
   private:
      string message;
};
#endif

oh forgot to put in my main function:

/********************************************************
*  This program tests some of the functionality of the 
*  MyVector class. Add your own tests to completely test 
*  the MyVector class and its methods.
********************************************************/
#include <iostream>
#include <iterator>
#include <algorithm>
#include "MyVector.h"

using namespace std;

int main()
{
    MyVector<int> numbers;

    cout << "Testing adding items to the MyVector..." << endl;
    cout << "Starting Capacity: " << numbers.capacity() << endl;

    const int TEST_LENGTH = 30;
    for(int i = 0; i < TEST_LENGTH; i++)
    {
        cout << "Pushing back " << i; 
        numbers.push_back(i);
        cout << "  Size: " << numbers.size();
        cout << "  Capacity: " << numbers.capacity() << endl;
    }

    cout << endl << "Testing accessing an index outside of range..." << endl;
    cout << "Accessing index 200 " << endl;
    try
    {
        cout << numbers[200] << endl;
    }
    catch(illegalIndex i)
    {
        cout << "Illegal index!" << endl;
    }
    cout << endl;

    cout << endl << "Testing removing items for the MyVector..." << endl;
    for(int i = 1; i <= TEST_LENGTH; i++)
    {
        cout << "Popping back #" << i; 
        numbers.pop_back();
        cout << "  Size: " << numbers.size();
        cout << "  Capacity: " << numbers.capacity() << endl;
    }

    MyVector<char> name;

    cout << endl;
    name.push_back('C');
    name.push_back('S');
    name.push_back('S');
    name.at(2) = 'E';

    cout << endl << "name contains: ";
    for (int i = 0; i < name.size(); i++)
        cout << name.at(i);
    cout << endl;

    cout << endl << "Creating name2 from name" << endl;
    MyVector<char> name2 = name;
    cout << "Modifying name2..." << endl;
    name2[0] = 'B';

    cout << "name contains: ";
    for (int i = 0; i < name.size(); i++)
        cout << name.at(i);
    cout << endl;

    cout << "name2 contains: ";
    for (int i = 0; i < name2.size(); i++)
        cout << name2.at(i);
    cout << endl;

    cout << endl << "Clearing name" << endl;
    name.clear();

    cout << "name contains: ";
    for (int i = 0; i < name.size(); i++)
        cout << name.at(i);
    cout << endl;

    cout << "name2 contains: ";
    for (int i = 0; i < name2.size(); i++)
        cout << name2.at(i);
    cout << endl;

    /****************************************************
    * Add code to test your iterator if you are in the 
    *    honors section....
    * Make sure that algorithms such as reverse and 
    *    accumulate
    ****************************************************/

    system("pause");
    return EXIT_SUCCESS;
}

>>LINK : fatal error LNK1561: entry point must be defined

Thats usually means that you haven't defined main. What type of project did you create?
What type of IDE?

>> oh forgot to put in my main function:

Either you forget to breath, don't even forget the int main()!

i did put in main...though the error is fixed i made a new empty project and copied the files there...
now i am getting errors that i can cannot use element to acess functions of my arrayList class...

element is pointer defined in arrayList is it wrong to use that pointer in myVector to access functions of arrayList?

if so pls suggest some alternate way

This article has been dead for over six months. Start a new discussion instead.