Cannot convert argument 'int' to 'char &'

Question

I am receiving a compiler error that I don't understand, and don't know how to deal with it properly. If anyone could offer me some advice on how to fix it I would be much appreciated. The error reads:

Error   1   error C2664: 'char myVector<char>::at(T &) const' : cannot convert argument 1 from 'int' to 'char &'

It's on line 159 of the header code where it reads out << rho.at(n);.

Driver:

#include <iostream>
#include "vectorHeader.h"

using namespace std;

int main()
{
const char START = 'A';
const int MAX = 12;

// create a vector of doubles
myVector<char> vectD;

// push some values into the vector
for (int i = 0; i < MAX; i++)
{
    vectD.push_back(START + i);
}

// remove the last element
vectD.pop_back();

// add another value
vectD.push_back('Z');

// test memory management
myVector<char> vectD2 = vectD;
// display the contents
cout << "\n[";
for (int i = 0; i < vectD2.size() - 1; i++)
{
    cout << vectD2[i] << ", ";
}

cout << "..., " << vectD2.last() << "]\n";


system("PAUSE");
return 0;

}

Header:

#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <fstream>
#include <stdexcept>


//Declaring constant
const int VECTOR_CAP = 2;

template <class T>
class myVector
{
private:
//Setting data members
T* vectorData;
int cap;
int numElements;

public:
//Default constructor
//Purpose: Creates a vector
//Parameters: None
//Returns: None
myVector();

//Parameterized constructor
//Purpose: Creates a vector capacity of n
//Parameters: None
//Returns: None
myVector(const T&);

//Copy Constructor
//Purpose: Copy data into vector
//Parameters: myVector object
//Returns: None
myVector(const myVector& copy)
{
    numElements = copy.numElements;
    vectorData = new T [numElements];
    for (int i = 0; i < numElements; i++)
    {
        this->vectorData[i] = copy.vectorData[i];
    }
}

//Destructor
//Purpose:Deletes any dynamically allocated storage
//Parameters: None
//Returns: None
~myVector();

//Size function
//Purpose: returns the size of your vector
//Parameters: None
//Returns: The size of your vector as an integer
int size() const;

//Capacity function
//Purpose: Returns the capacity of the vector
//Parameters: None
//Returns: Maximum value that your vector can hold
int capacity() const;

//Clear function
//Purpose: Deletes all of the elements from the vector and resets its size to zero
// and its capacity to two; thus becoming empty
//Parameters: None
//Returns: None
void clear();

//push_back function
//Purpose: Adds the integer value n to the end of the vector
//Parameters: Takes a integer to be placed in the vector
//Returns: None
void push_back(const T& n)
{
    //If statement to handle if array is full 
    if (numElements == cap)
    {
        //Doubling the capacity 
        cap = cap * VECTOR_CAP;
        //Allocating new array 
        T* newVectorData = new T[cap];
        //Copying data
        for (int i = 0; i < numElements; i++) newVectorData[i] = vectorData[i];
        //Deleting previous data
        delete[] vectorData;
        //Pointing to new data
        vectorData = newVectorData;
    }
    //Storing data
    vectorData[numElements++] = n;
}

//at function
//Purpose: Returns the value of the element at position n in the vector
//Parameters: None
//Returns: Returns your current place with the vector
T at(T&) const;

//assignment
//Purpose: Overload the = operator
//Parameters: The two myVector objects we want to assign
//Returns: The assignment
myVector operator=(const myVector&);

void pop_back();

int last();

myVector operator[](const myVector&);

};

//Independant Functions

template <typename T>
int myVector<T>::capacity() const
{
return cap;
}

template <typename T>
myVector<T> myVector<T>::operator=(const myVector& rho)
{
//Test for assingment
if (this == &rho)
{
    return *this;
}

//Delete lho
delete[] this->vectorData;

//Creating new array to fit rho data
cap = rho.cap;
this->vectorData = new int[cap];

//Copying data
for (int i = 0; i < numElements; i++)
{
    this->vectorData[i] = rho.vectorData[i];
}

    //Returning myVector object
    return *this;
}


template <typename T>
std::ostream& operator<<(std::ostream& out, const myVector<T>& rho)
{
    for (int n = 0; n < rho.size(); n++)
    {
        out << rho.at(n);
    }
    return out;
}

Answer 1

Your declaration of myVector::at(T&) takes the templated type as an argument. You need to declare it as

T at(unsigned int&) const

That way you can use the parameter as an index.

Answer 2

Exactly what it says on the tin. When you have

T at(T&) const;

in a myVector<char>, that translates to

char at(char&) const;

and an int cannot be bound to a reference to char. I think you meant to say

T at(int) const;

or, better,

T at(std::size_t) const;

because std::size_t is usually (by convention) used for this sort of thing. int is implicitly convertible to std::size_t, so that will also just work.