21

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 prevent using invalid memory reference.

This code is similar, but using a dynamic array:

#include <cstddef> #include <iostream> template< typename T, std::size_t N > inline std::size_t size( T(&)[N] ) { return N ; } int main() { int a[] = { 0, 1, 2, 3, 4, 5, 6 }; const void* b[] = { a, a+1, a+2, a+3 }; std::cout << size(a) << '\t' << size(b) << '\n' ; }
Improve this question
7
  • 2
    You need to remember the size, it's not possible to get the size from the pointer only. Commented Feb 25, 2014 at 8:46
  • 3
    Easy: use std::vector instead of juggling pointers yourself. (If you really want to juggle pointers, then the answer is no. So don't do that.) Commented Feb 25, 2014 at 8:49
  • Raw arrays are so idiot that they dont know how many elements they have in them. Use vector. Commented Feb 25, 2014 at 8:50
  • @FredrickGauss In C++ a raw array has a type, which contains size information. This is a different problem: all you get from new is a pointer to a the first element of an array. Commented Feb 25, 2014 at 8:51
  • 2
    Or a pointer to the first element of an array, if we want to be type-aware in our language Commented Feb 25, 2014 at 8:52

1 Answer 1

Reset to default
48

You can't. The size of an array allocated with new[] is not stored in any way in which it can be accessed. Note that the return type of new [] is not an array - it is a pointer (pointing to the array's first element). So if you need to know a dynamic array's length, you have to store it separately.

Of course, the proper way of doing this is avoiding new[] and using a std::vector instead, which stores the length for you and is exception-safe to boot.

Here is what your code would look like using std::vector instead of new[]:

size_t n; // Size needed for array - size_t is the proper type for that cin >> n; // Read in the size std::vector<int> a(n, 0); // Create vector of n elements initialised to 0 . . . // Use a as a normal array // Its size can be obtained by a.size() // If you need access to the underlying array (for C APIs, for example), use a.data() // Note: no need to deallocate anything manually here
Improve this answer
Sign up to request clarification or add additional context in comments.

14 Comments

Not sure I understand why this has been downvoted. Actually, I'm sure I don't...
I've observed a strong correlation between no good reason to downvote and no comment/suggestion to improve/fix the answer.
@evergreen I've expanded the answer with how your code would look with std::vector instead of new[]
And you might as well say it: the way you spell "dynamic array" in C++ is std::vector, not T* array = new T[]. One can't stress enough that there is never a reason to use array new (or at least almost never---but I've been using C++ for more than 20 years, and I've never found a case where array new was appropriate).
@Angew Any reasonable vector class (and the standard requires it of std::vector) will separate allocation and initialization, probably be using the std::operator new() function and placement new. Otherwise, you end up having to default construct all of the elements, and then assign to them, rather than constructing them with the desired initializer immediately. (When I first started C++, there wasn't a std::vector, and of course, the first thing one did was write your own vector and string classes.)
|

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.