Pointers to elements of arrays are allowed to point to a valid element, or one past the end. If you increment a pointer in a way that goes more than one past the end, the behavior is undefined. For your 0-sized array, p is already pointing one past the end, so incrementing it is not … Read more
There are many tradeoffs involved here and I don’t think that there’s a “correct” answer to this question. If you implement the stack using a linked list with a tail pointer, then the worst-case runtime to push, pop, or peek is O(1). However, each element will have some extra overhead associated with it (namely, the … Read more
To make use of the range-based for-loop you have to provide either begin() and end() member functions or overload the non-member begin() and end() functions. In the latter case, you can wrap your range in a std::pair and overload begin() and end() for those: namespace std { template <typename T> T* begin(std::pair<T*, T*> const& p) … Read more
The first method cannot be used to create dynamic 2D arrays because by doing: int *board[4]; you essentially allocated an array of 4 pointers to int on stack. Therefore, if you now populate each of these 4 pointers with a dynamic array: for (int i = 0; i < 4; ++i) { board[i] = new … Read more
I think, it’s because C++ provides superior solutions: std::vector<T> and std::array<T,N> (C++11); though the latter is not dynamic as such but it’s superior to raw arrays. You can always know the size, no matter which function you pass the vector or array. Since C cannot provide these solutions, C99 came up with Variable Length Array … Read more
int main() { int size; std::cin >> size; int *array = new int[size]; delete [] array; return 0; } Don’t forget to delete every array you allocate with new.
As of Delphi 4, Delphi supports dynamic arrays. You can modify their sizes at run time and they will retain the data you stored in other elements at the old size. They can hold elements of any homogeneous type, including records and other arrays. You can declare a dynamic array the same as you declare … Read more
Base* p = new Base[n] creates an n-sized array of Base elements, of which p then points to the first element. Base* p = new Derived[n] however, creates an n-sized array of Derived elements. p then points to the Base subobject of the first element. p does not however refer to the first element of … Read more
N3639 proposes to add local runtime-sized arrays with automatic storage duration to C++. N2648 says that in keeping with C++ practice, std::dynarrays are usable with more than just automatic variables. But to take advantage of the efficiency stack allocation, we wish to make dynarray optimizable when used as an automatic variable. In short, C11 style … Read more
It’s a follow on from the fundamental rule of “don’t pay for what you don’t need”. In your example delete[] a; doesn’t need to know the size of the array, because int doesn’t have a destructor. If you had written: std::string* a; a = new std::string[n]; … delete [] a; Then the delete has to … Read more