Overloading the << Operator.

[Sh0es]

I'm struggling to get my code to compile, but I currently have only one error in my innermost class.

#include <iostream>

template <class T>
class ArrayList
{
private:
    T* data;
    unsigned int size;

public:
    void append(T d); //adds d at the end of the list
    void insert(T d, unsigned int p); //adds d at position p
    void remove(T d); //finds d and removes it from the list

    unsigned int getSize() const;
    void display(); //alternative to the overloaded << operator
    T operator[](const unsigned int& p) const;
    friend std::ostream& operator<<(std::ostream& s, const ArrayList<T>& a);
    void operator=(const ArrayList<T>& a);
    bool operator==(const ArrayList<T>& a); //behaves like stringcomp
    void operator+=(const ArrayList<T>& a);
    bool litComp(char c[]);

    ArrayList();
    ArrayList(const ArrayList& c); //copy-constructor
    ArrayList(unsigned int s); //used to pre-allocate space
    ~ArrayList();
};

template <class T>
void ArrayList<T>::append(T d)
{
    T* temp = new T[size + 1];

    for(int i = 0; i < size; i++)
        temp[i] = data[i];
    
    data[size] = d;

    data = temp;
    ++size;
    delete[] temp;
}

template <class T>
void ArrayList<T>::insert(T d, unsigned int p)
{
    T* temp = new T[size + 1];

    for(int i = 0; i < size; i++)
    {
        if(i = p)
            temp[i] = d;
        else
            temp[i] = data[i];
    }

    data = temp;
    ++size;
    delete[] temp;
}

template <class T>
void ArrayList<T>::remove(T d)
{
    T* temp = new T[size - 1];

    for(int i = 0; i < size; i++)
    {
	if(data[i] == d)
        ++i;
	else
        temp[i] = data[i];
    }

    data = temp;
    --size;
    delete[] temp;
}

template <class T>
unsigned int ArrayList<T>::getSize() const
{
    return size;
}

template <class T>
void ArrayList<T>::display() //My compiler tells me "<< is not a member of ArrayList<T>."
{
    for(int i = 0; i < size; i++)
        std::cout << data[i] << std::endl << std::endl;
}

template <class T>
T ArrayList<T>::operator[](const unsigned int& p) const
{
    return data[p];
}

template <class T>
void ArrayList<T>::operator=(const ArrayList<T>& a)
{
    data = new T[a.getSize()];
    size = a.getSize();

    for(int i = 0; i < size; i++)
	data[i] = a[i];
}

template <class T>
std::ostream& ArrayList<T>::operator<<(std::ostream& s, const ArrayList<T>& a)
{
    for(int i = 0; i < a.getSize(); i++)
        s << a[i];

    return s;
}

template <class T>
bool ArrayList<T>::operator==(const ArrayList<T>& a)
{
    int i = 0;
    bool equal = true;
    while(data[i] != '\0' || a[i] != '\0')
    {
        if(data[i] != a[i])
        equal = false;
    }
	
    return equal;
}

template <class T>
void ArrayList<T>::operator+=(const ArrayList<T>& a)
{
    for(int i = 0; i < a.getSize(); i++)
        append(a[i]);
}

template <class T>
bool ArrayList<T>::litComp(char c[])
{
    bool eq = true;
    for(int i = 0; (data[i] || c[i]) != '\0'; i++)
    {
        if(data[i] != c[i])
    eq = false;
    }
	
	return eq;
}

template <class T>
ArrayList<T>::ArrayList()
{
    data = new T;
    size = 0;
}
template <class T>
ArrayList<T>::ArrayList(const ArrayList<T>& c)
{
	*this = c;
}
template <class T>
ArrayList<T>::ArrayList(unsigned int s)
{
    data = new T[s];
    size = s;
}

template <class T>
ArrayList<T>::~ArrayList()
{
    if(data != NULL)
        delete[] data;
}

What else can you tell me?

[TwilightSpectre]

The main problem I can see is that on line 111 you are saying that operator<< is a member of ArrayList, when it isn't, it's just a friend.

What are the errors that you are getting? That's a lot easier than just guessing based on the title of your post.

[Sh0es]

Thanks, that cleared the error right up.

[Sh0es]

New issue on the same subject, so I'm putting it here.

    friend std::ostream& operator<<(std::ostream& s, const Account& h)
    {
        s << "Login: " << h.getUser() << std::endl; //apparently this is trying to convert a const instance to a reference
        s << "Directory: " << h.getHome() << std::endl; //same with the other three
        s << "Shell: " << h.getShell() << std::endl;
        s << "Gecos: " << h.getGecos() << std::endl;

        return s;
    }

Will provide full file upon request

[OxBADC0DE]

Why are the member and non-member overloaded operators returning void?! There's a lot wrong with this code: insert and append is totally incorrect, I don't know where to start the correction. For example, every call to append moves the existing elements without freeing up the old one, you then point

data

to

temp

, then

delete[]

it again.

A very naïve possible implementation can be found here https://github.com/iamOgunyinka/maths/blob/master/vector.h

NOTE: If I wasn't typing on my phone, I'd have loved to take my time to point the OP in the right direction -- one step at a time.

[TwilightSpectre]

In answer to your question, @Sh0es, we probably need to see at least the details for your Account class. However, I can guess what is going on.

You are passing a const reference of your class. This means it is immutable, so you are not allowed to change it in any way. Most likely, your 'get' functions have not been made immutable, so you will need to change them. Here is what it should look like

class Account {
    public:
        std::string getUser() const { // note the const
            return this->_user; 
        } 

        // same for your other 'get' functions
        // ...

    private:
        std::string _user;
        // ...
};