dynamic-arrays

This question already has an answer here: How to get size c++ dynamic array 3 answers Code for dynamic array by entering size and storing it into "n" variable, but I want to get the array length from a template method and not using "n". int* a = NULL; // Pointer to int, initialize to nothing. int n; // Size needed for array cin >> n; // Read in the size a = new int[n]; // Allocate n ints and save ptr in a. for (int i=0; i<n; i++) { a[i] = 0; // Initialize all elements to zero. } . . . // Use a as a normal array delete [] a; // When done, free memory pointed to by a. a = NULL; // Clear a to

First timer on this website, so here goes.. I'm a newbie to C++ and I'm currently working through the book "Data structures using C++ 2nd ed, of D.S. Malik". In the book Malik offers two ways of creating a dynamic two-dimensional array. In the first method, you declare a variable to be an array of pointers, where each pointer is of type integer. ex. int *board[4]; ..and then use a for-loop to create the 'columns' while using the array of pointers as 'rows'. The second method, you use a pointer to a pointer. int **board; board = new int* [10]; etc. My question is this: which is the better

As we already know, VLA (standardized in C99 ) are not part of the standard in C++. So the code below is "illegal" in C++ : void foo(int n) { int vla[n]; for (int i = 0; i < n; ++i) { vla[i] = i; } } Despite of that the compiler ( g++ and clang++ ) accepts the code as valid syntax, producing just a warning in case -pedantic flag is enable . ISO C++ forbids variable length array ‘vla’ [-Wvla] My questions are: Why does the compiler accept that declaration? The compiler cannot just reject an array in which length [is-no-know-at-compile-time] ? Is there a sort of compatibility syntax rule to

I found the following snippet in the C++03 Standard under 5.3.5 [expr.delete] p3 : In the first alternative ( delete object ), if the static type of the object to be deleted is different from its dynamic type, the static type shall be a base class of the operand’s dynamic type and the static type shall have a virtual destructor or the behavior is undefined. In the second alternative ( delete array ) if the dynamic type of the object to be deleted differs from its static type, the behavior is undefined. Quick review on static and dynamic types: struct B{ virtual ~B(){} }; struct D : B{}; B* p =

In PHP, you can dynamically add elements to arrays by the following: $x = new Array(); $x[] = 1; $x[] = 2; After this, $x would be an array like this: {1,2} . Is there a way to do something similar in Java? Look at java.util.LinkedList or java.util.ArrayList List<Integer> x = new ArrayList<Integer>(); x.add(1); x.add(2); Arrays in Java have a fixed size, so you can't "add something at the end" as you could do in PHP. A bit similar to the PHP behaviour is this: int[] addElement(int[] org, int added) { int[] result = Arrays.copyOf(org, org.length +1); result[org.length] = added; return result; }