How to implement dynamic array without pointers in c++? [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 24 days ago.
Improve this question
I was told that you should avoid using pointers or new in c++ but I could not figure out how. I implemented dynamic array with iterator class. Here is the code:
Custom vector and iterator:
#include <iostream>
template<class T> class Myvector{
private:
int size;
int capacity;
T* objects;
void add_capacity(){
int newCapacity = capacity * 2 +1;
T *newArray = new T[ newCapacity ];
for( int i = 0; i < size; ++i )
newArray[ i ] = std::move( objects[ i ] );
capacity = newCapacity;
std::swap( objects, newArray );
delete [ ] newArray;
}
public:
Myvector(){
objects = new T[1];
capacity = 1;
size = 0;
}
void add(T obj){
if (capacity == size){
add_capacity();
}
objects[size] = obj;
size += 1;
}
class Iterator
{
public:
T* operator->() { return ptr; }
Iterator(T *p) {
ptr= p;
}
Iterator operator++() {
++ptr;
return *this;
}
bool operator!=(const Iterator & other) const{return ptr != other.ptr;}
const T & operator*() const{return *ptr;}
private:
T * ptr; // Pointer to v.
};
Iterator begin() {
//return &objects[0];
return Iterator(&objects[0]);
}
Iterator end(){
//return &objects[size];
return Iterator(&objects[size]);
}
};
So the question is that is is possible to implement this without pointers or new? I want to get better in c++.

Answer 1

What you heard is true. You should avoid raw owning pointers and new whenver possible.
Just don't miss the last part: "whenever possible". Raw owning pointers and new are not completely banned. They are tools that have their applications. Using an array with dynamic size is not one of them. There is std::vector. Use it.
Whenever you think you need to use new and a raw owning pointer you should revisit <memory> for smart pointers and the containers library. It is rare to not find what you need in there. And if you don't you will use a third party library rather than implementing your own container.
However, if we are talking about reimplementing std::vector (which you wouldn't do usually, but lets say you did), then things are different.
If you look at implementation of std::vector you will find that it does use raw pointers. The point is that this usage of raw pointers is encapsulated. std::vector grants you access to a pointer to the underlying array, but you never have to worry about calling delete on that pointer.
Your MyVector fails to manage ownership of the data it allocates. It has no destructor, it cannot be copied and it has more issues. If you do write a class that manages a ressource (can be a raw owning pointer, can be something else) you need to read about the rule of 3/5. Though, what you should follow whenever possible is the rule of 0 (at the end of the linked article).
This last suggestion, "prefer rule of 0", is basically just "prefer container and smart pointer" for class members. Both "rules" help you to write simpler code. Code that has on average less bugs. You can choose to not follow the suggestion, but then you are on your own. Then you must take care to correctly manage the resources. And if you fail to do so you will be in trouble.