How can you print a dynamic array in C++?

Question

Below is my current code for my latest assignment and I cannot figure out what the problem is printing the array. Forgive me for the crappy code, in my class we were thrown into C++ and none of us have ever used it before so it may be a simple mistake but no one in the house can help me.

Header file DynamicArray.h:

//
// DynamicArray.h

///#include <rpcndr.h>

#ifndef DYNAMIC_DYNAMICARRAY_H
#define DYNAMIC_DYNAMICARRAY_H

#endif //DYNAMIC_DYNAMICARRAY_H

//      union
//      intersection
//      relative complement
//      insertion - if the element is already in the set, then nothing happens
//      deletion - if the element is not in the set, then nothing happens
//      query to check whether an element is in a set
//      query to find the number of number of elements in a set
//      display the set
//destructor
//       copy constructor
// ***********************************overloading assignment operator***************************************************
class DynamicArray{
public:
    DynamicArray(int size);
    DynamicArray(const DynamicArray &original, int Size);
///     DynamicArray(int Size);
    ~DynamicArray();

    void Union();
    void Intersection();
    void Complement();
    int Insert(int position, int entry, int size);
    int Delete(int position, int entry, int size);
    bool Qelement(int size, int entry);
    int Qset(int size);


    int size = 20;
    int *array;
};

    //
// 
//

Source file DynamicA.cpp- here I define the constructors and member functions:

//
// DynamicA.cpp
//

//Union();
//Intersection();
//Complement();
//Insert();
//Delete();
//Qelement();
//Qset();
#include <iostream>
#include "DynamicArray.h"
using namespace std;

DynamicArray::DynamicArray(int &size = 30){
    size = 20;
    *array = new int[size];
    for(int i = 0; i < size; i++){
        array[i] = 0;
    };
}

///  DynamicArray::DynamicArray(int Size) {
///
///    }

DynamicArray::DynamicArray(const DynamicArray &original, int size) {
    size  = original.size;
    array = new int[size];
    for (int i = 0; i < size; i++) {
        array[i] = original.array[i];
    }
}

DynamicArray::~DynamicArray(){
    delete[] array;
}

void DynamicArray::Union(){

}

void DynamicArray::Intersection() {

}

void DynamicArray::Complement(){

}

int DynamicArray::Insert(int position, int entry, int size) {
    if(!Qelement()){
        for(int i = size+1; i > position+1; i--){
            array[i] = array[i-1];
        }
        array[position] = entry;
    }
}

int DynamicArray::Delete(int position, int entry, int size){
    for(int i = 0; i < size; i++){
        if(array[i] == entry) {
            for(int x = i; x < size; i++){
                array[x] = array[x+1];
            }
            size--;
        }
    }
}

bool DynamicArray::Qelement(int size, int entry) {
    for(int i = 0; i < size; i++){
        if(array[i] == entry){
            return true;
        }
    }
}

int DynamicArray::Qset(int size){
    return size;
}

main.cpp - this is where my issue is. The error I continue to receive is that dArray is not an array.

//main.cpp
    #include <iostream>
//#include <DynamicArray.h>
#include "DynamicArray.h"
//#include "DynamicA.cpp"

//using namespace std;

int main() {
    DynamicArray dArray();
    for(int i = 0; i < array; i++) {
        cout << dArray[i];
    }
}

Answer 1

Your class DynamicArray is not an array, the compiler has it right. It's just a class you've defined. For your code to work, you need to overload DynamicArray::operator[](int), for example, like so:

#include <cassert>
int DynamicArray::operator[](int idx)
{
    assert(idx < size);
    return array[i];
}

The reason is that operator[] is only defined for the built-in array type, where it has an established meaning and understood by the compiler. But you have defined an arbitrary class, and your understanding that it is an array is only your understanding, i.e. an assumption, which in no way is perceived by the compiler, so to say.

Now, let me point this one out before you run into issues caused by that mistake: the fields size and array must be private or at least protected! Read up on encapsulation in C++, as well as the other two or three founding principles of this language. You may wonder how to access the size of the array form the outside given this change, well that's where the so-called getter-setter methods come into play. Define int DynamicArray::size() const { return size; } to let the array tell its size to its clients.

Now you can use the previously defined operator[](int) with int size():

DynamicArray myArray(5);
for(int i = 0; i < myArray.size(); ++i)
    std::cout << myArray[i] << " ";

Other errors: two pointed out by@crashmstr: *array = new int[size]; should be array = new int[size]; and DynamicArray myArray(); isn't going to build, since this calls the undefined default constructor.