This question already has answers here:
How to find the size of an array (from a pointer pointing to the first element array)?
(17 answers)
Closed 4 years ago.
I'm having trouble finding the length of an pointer array. Let's say I have:
char array[40] = "hello"; // size 40
int length = sizeof array / sizeof array[0]; // no problem returns 40
//How do I get the length of the array with only a pointer to the first element in that array?
char* pchar = array;
//if
std::strlen(pchar); // this returns the length of 5... i want length 40
//if
int count = 0;
while(true)
{
if(*(pchar + count) == '\0') // returns 5...
break;
count++;
}
How do I get it to return length 40 just from a pointer to the first element in the array?
I found that I can do this.
int count = 0;
while(true)
{
if(*(pchar + count) == '\0' && *(pchar + count + 1) != '\0')
break;
count++;
}
This returns 39, this is good but I feel like this can be buggy in some situations.
You can't, I'm afraid. You need to pass the length of the array to anyone who needs it. Or you can use a std::array or std::vector or similar, which keep track of the length themselves.
You can't. And the moral is, don't use pointers and arrays, use vectors. You can always get the size of a vector.
C++ has proper string type:
std::string
which you may find helpful here. Even if you're passing it to function that accepts const char*, it has .c_str() method that allows you to pass it to function that accept a pointer. If the other function needs to modify the string, you can use &str[0] which is valid for many implementations of C++, and is required to work for C++11. Just make sure you resize() them to the correct size.
Some of the other containers in C++ are:
std::array (C++11) Array of constant size. Better than plain old C array, as it has size() method.
std::vector Dynamic array (Java ArrayList equivalent)
As for your question - there is no way to find size of a pointed array. How could you even do that? It's just a stupid pointer.
It is true that you cannot get the array size from a pointer to an element of the array.
If the reason you only have a pointer is because you are implementing a function that takes an array parameter as an argument like this:
void foo (T *p) {
// p is a pointer to T
}
then you can use a template function instead to get the array size to the function.
template <unsigned N, typename T>
void foo (T (&p)[N]) {
// p is a reference to an array[N] of T
std::cout << "array has " << N << " elements" << std::endl;
std::cout << "array has "
<< sizeof(p)/sizeof(p[0])
<< " elements"
<< std::endl;
}
int main ()
{
int array[40];
char array2[25];
foo(array);
foo(array2);
return 0;
}
If you want to keep simple and not use #include <array.h>, you can make a struct where you array sizes are. A little bit like:
struct
{
int* int_Array;
int array_Size;
}
That way, you can to whatever you want (like deleting your instances or something)
Related
I am writing a simple function that returns the largest integer in an array. The problem I am having is finding the number of elements in the array.
Here is the function header:
int largest(int *list, int highest_index)
How can I get the number of integers in the array 'list'.
I have tried the following methods:
int i = sizeof list/sizeof(int); //returns incorrect value
int i = list.size(); // does not compile
Any help will be greatly appreciated!
C++ is based on C and inherits many features from it. In relation to this question, it inherits something called "array/pointer equivalence" which is a rule that allows an array to decay to a pointer, especially when being passed as a function argument. It doesn't mean that an array is a pointer, it just means that it can decay to one.
void func(int* ptr);
int array[5];
int* ptr = array; // valid, equivalent to 'ptr = &array[0]'
func(array); // equivalent to func(&array[0]);
This last part is the most relevant to your question. You are not passing the array, you are passing the address of the 0th element.
In order for your function to know how big the incoming array is, you will need to send that information as an argument.
static const size_t ArraySize = 5;
int array[ArraySize];
func(array, ArraySize);
Because the pointer contains no size information, you can't use sizeof.
void func(int* array) {
std::cout << sizeof(array) << "\n";
}
This will output the size of "int*" - which is 4 or 8 bytes depending on 32 vs 64 bits.
Instead you need to accept the size parameters
void func(int* array, size_t arraySize);
static const size_t ArraySize = 5;
int array[ArraySize];
func(array, ArraySize);
Even if you try to pass a fixed-sized array, it turns out this is syntactic sugar:
void func(int array[5]);
http://ideone.com/gaSl6J
Remember how I said that an array is NOT a pointer, just equivalent?
int array[5];
int* ptr = array;
std::cout << "array size " << sizeof(array) << std::endl;
std::cout << "ptr size " << sizeof(ptr) << str::endl;
array size will be 5 * sizeof(int) = 20
ptr size will be sizeof(int *) which will be either 4 or 8 bytes.
sizeof returns the size of the type being supplied, if you supply an object then it deduces the type and returns the size of that
If you want to know how many elements of an array are in the array, when you have the array and not a pointer, you can write
sizeof(array) / sizeof(array[0])
or
sizeof(array) / sizeof(*array)
There's no way to do that. This is one good reason (among many) to use vectors instead of arrays. But if you must use an array then you must pass the size of the array as a parameter to your function
int largest(int *list, int list_size, int highest_index)
Arrays in C++ are quite poor, the sooner you learn to use vectors the easier you will find things.
Pointers do not have information about the number of elements they refer to. If you are speaking about the first argument of the function call then if list is an array you can indeed use the syntax
sizeof( list ) / sizeof( int )
I would like to append that there are three approaches. The first one is to use arrays passed by reference. The second one is to use pointer to the first element and the number of elements. And the third one is to use two pointers - the start pointer and the last pointer as standard algorithms usually are defined. Character arrays have an additional possibility to process them.
The simple answer is you cannot. You need to store it in a variable. The great advantage with C++ is it has STL and you can use vector. size() method gives the size of the vector at that instant.
#include<iostream>
#include<vector>
using namespace std;
int main () {
vector<int> v;
for(int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << v.size() << endl;
for(int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << v.size() << endl;
return 0;
}
output:
10
20
Not tested. But, should work. ;)
You need to remember in a variable array size, there is no possibility to retrieve array size from pointer.
const int SIZE = 10;
int list[SIZE];
// or
int* list = new int[SIZE]; // do not forget to delete[]
My answer uses a char array instead of an integer array but I do hope it helps.
You can use a counter until you reach the end of the array. Char arrays always end with a '\0' and you can use that to check the end of the array is reached.
char array[] = "hello world";
char *arrPtr = array;
char endOfString = '\0';
int stringLength = 0;
while (arrPtr[stringLength] != endOfString) {
stringLength++;
}
stringLength++;
cout << stringLength << endl;
Now you have the length of the char array.
I tried the counting the number of integers in array using this method. Apparently, '\0' doesn't apply here obviously but the -1 index of the array is 0. So assuming that there is no 0, in the array that you are using. You can replace the '\0' with 0 in the code and change the code to use int pointers and arrays.
I am writing a simple function that returns the largest integer in an array. The problem I am having is finding the number of elements in the array.
Here is the function header:
int largest(int *list, int highest_index)
How can I get the number of integers in the array 'list'.
I have tried the following methods:
int i = sizeof list/sizeof(int); //returns incorrect value
int i = list.size(); // does not compile
Any help will be greatly appreciated!
C++ is based on C and inherits many features from it. In relation to this question, it inherits something called "array/pointer equivalence" which is a rule that allows an array to decay to a pointer, especially when being passed as a function argument. It doesn't mean that an array is a pointer, it just means that it can decay to one.
void func(int* ptr);
int array[5];
int* ptr = array; // valid, equivalent to 'ptr = &array[0]'
func(array); // equivalent to func(&array[0]);
This last part is the most relevant to your question. You are not passing the array, you are passing the address of the 0th element.
In order for your function to know how big the incoming array is, you will need to send that information as an argument.
static const size_t ArraySize = 5;
int array[ArraySize];
func(array, ArraySize);
Because the pointer contains no size information, you can't use sizeof.
void func(int* array) {
std::cout << sizeof(array) << "\n";
}
This will output the size of "int*" - which is 4 or 8 bytes depending on 32 vs 64 bits.
Instead you need to accept the size parameters
void func(int* array, size_t arraySize);
static const size_t ArraySize = 5;
int array[ArraySize];
func(array, ArraySize);
Even if you try to pass a fixed-sized array, it turns out this is syntactic sugar:
void func(int array[5]);
http://ideone.com/gaSl6J
Remember how I said that an array is NOT a pointer, just equivalent?
int array[5];
int* ptr = array;
std::cout << "array size " << sizeof(array) << std::endl;
std::cout << "ptr size " << sizeof(ptr) << str::endl;
array size will be 5 * sizeof(int) = 20
ptr size will be sizeof(int *) which will be either 4 or 8 bytes.
sizeof returns the size of the type being supplied, if you supply an object then it deduces the type and returns the size of that
If you want to know how many elements of an array are in the array, when you have the array and not a pointer, you can write
sizeof(array) / sizeof(array[0])
or
sizeof(array) / sizeof(*array)
There's no way to do that. This is one good reason (among many) to use vectors instead of arrays. But if you must use an array then you must pass the size of the array as a parameter to your function
int largest(int *list, int list_size, int highest_index)
Arrays in C++ are quite poor, the sooner you learn to use vectors the easier you will find things.
Pointers do not have information about the number of elements they refer to. If you are speaking about the first argument of the function call then if list is an array you can indeed use the syntax
sizeof( list ) / sizeof( int )
I would like to append that there are three approaches. The first one is to use arrays passed by reference. The second one is to use pointer to the first element and the number of elements. And the third one is to use two pointers - the start pointer and the last pointer as standard algorithms usually are defined. Character arrays have an additional possibility to process them.
The simple answer is you cannot. You need to store it in a variable. The great advantage with C++ is it has STL and you can use vector. size() method gives the size of the vector at that instant.
#include<iostream>
#include<vector>
using namespace std;
int main () {
vector<int> v;
for(int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << v.size() << endl;
for(int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << v.size() << endl;
return 0;
}
output:
10
20
Not tested. But, should work. ;)
You need to remember in a variable array size, there is no possibility to retrieve array size from pointer.
const int SIZE = 10;
int list[SIZE];
// or
int* list = new int[SIZE]; // do not forget to delete[]
My answer uses a char array instead of an integer array but I do hope it helps.
You can use a counter until you reach the end of the array. Char arrays always end with a '\0' and you can use that to check the end of the array is reached.
char array[] = "hello world";
char *arrPtr = array;
char endOfString = '\0';
int stringLength = 0;
while (arrPtr[stringLength] != endOfString) {
stringLength++;
}
stringLength++;
cout << stringLength << endl;
Now you have the length of the char array.
I tried the counting the number of integers in array using this method. Apparently, '\0' doesn't apply here obviously but the -1 index of the array is 0. So assuming that there is no 0, in the array that you are using. You can replace the '\0' with 0 in the code and change the code to use int pointers and arrays.
I am writing a simple function that returns the largest integer in an array. The problem I am having is finding the number of elements in the array.
Here is the function header:
int largest(int *list, int highest_index)
How can I get the number of integers in the array 'list'.
I have tried the following methods:
int i = sizeof list/sizeof(int); //returns incorrect value
int i = list.size(); // does not compile
Any help will be greatly appreciated!
C++ is based on C and inherits many features from it. In relation to this question, it inherits something called "array/pointer equivalence" which is a rule that allows an array to decay to a pointer, especially when being passed as a function argument. It doesn't mean that an array is a pointer, it just means that it can decay to one.
void func(int* ptr);
int array[5];
int* ptr = array; // valid, equivalent to 'ptr = &array[0]'
func(array); // equivalent to func(&array[0]);
This last part is the most relevant to your question. You are not passing the array, you are passing the address of the 0th element.
In order for your function to know how big the incoming array is, you will need to send that information as an argument.
static const size_t ArraySize = 5;
int array[ArraySize];
func(array, ArraySize);
Because the pointer contains no size information, you can't use sizeof.
void func(int* array) {
std::cout << sizeof(array) << "\n";
}
This will output the size of "int*" - which is 4 or 8 bytes depending on 32 vs 64 bits.
Instead you need to accept the size parameters
void func(int* array, size_t arraySize);
static const size_t ArraySize = 5;
int array[ArraySize];
func(array, ArraySize);
Even if you try to pass a fixed-sized array, it turns out this is syntactic sugar:
void func(int array[5]);
http://ideone.com/gaSl6J
Remember how I said that an array is NOT a pointer, just equivalent?
int array[5];
int* ptr = array;
std::cout << "array size " << sizeof(array) << std::endl;
std::cout << "ptr size " << sizeof(ptr) << str::endl;
array size will be 5 * sizeof(int) = 20
ptr size will be sizeof(int *) which will be either 4 or 8 bytes.
sizeof returns the size of the type being supplied, if you supply an object then it deduces the type and returns the size of that
If you want to know how many elements of an array are in the array, when you have the array and not a pointer, you can write
sizeof(array) / sizeof(array[0])
or
sizeof(array) / sizeof(*array)
There's no way to do that. This is one good reason (among many) to use vectors instead of arrays. But if you must use an array then you must pass the size of the array as a parameter to your function
int largest(int *list, int list_size, int highest_index)
Arrays in C++ are quite poor, the sooner you learn to use vectors the easier you will find things.
Pointers do not have information about the number of elements they refer to. If you are speaking about the first argument of the function call then if list is an array you can indeed use the syntax
sizeof( list ) / sizeof( int )
I would like to append that there are three approaches. The first one is to use arrays passed by reference. The second one is to use pointer to the first element and the number of elements. And the third one is to use two pointers - the start pointer and the last pointer as standard algorithms usually are defined. Character arrays have an additional possibility to process them.
The simple answer is you cannot. You need to store it in a variable. The great advantage with C++ is it has STL and you can use vector. size() method gives the size of the vector at that instant.
#include<iostream>
#include<vector>
using namespace std;
int main () {
vector<int> v;
for(int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << v.size() << endl;
for(int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << v.size() << endl;
return 0;
}
output:
10
20
Not tested. But, should work. ;)
You need to remember in a variable array size, there is no possibility to retrieve array size from pointer.
const int SIZE = 10;
int list[SIZE];
// or
int* list = new int[SIZE]; // do not forget to delete[]
My answer uses a char array instead of an integer array but I do hope it helps.
You can use a counter until you reach the end of the array. Char arrays always end with a '\0' and you can use that to check the end of the array is reached.
char array[] = "hello world";
char *arrPtr = array;
char endOfString = '\0';
int stringLength = 0;
while (arrPtr[stringLength] != endOfString) {
stringLength++;
}
stringLength++;
cout << stringLength << endl;
Now you have the length of the char array.
I tried the counting the number of integers in array using this method. Apparently, '\0' doesn't apply here obviously but the -1 index of the array is 0. So assuming that there is no 0, in the array that you are using. You can replace the '\0' with 0 in the code and change the code to use int pointers and arrays.
I am writing a simple function that returns the largest integer in an array. The problem I am having is finding the number of elements in the array.
Here is the function header:
int largest(int *list, int highest_index)
How can I get the number of integers in the array 'list'.
I have tried the following methods:
int i = sizeof list/sizeof(int); //returns incorrect value
int i = list.size(); // does not compile
Any help will be greatly appreciated!
C++ is based on C and inherits many features from it. In relation to this question, it inherits something called "array/pointer equivalence" which is a rule that allows an array to decay to a pointer, especially when being passed as a function argument. It doesn't mean that an array is a pointer, it just means that it can decay to one.
void func(int* ptr);
int array[5];
int* ptr = array; // valid, equivalent to 'ptr = &array[0]'
func(array); // equivalent to func(&array[0]);
This last part is the most relevant to your question. You are not passing the array, you are passing the address of the 0th element.
In order for your function to know how big the incoming array is, you will need to send that information as an argument.
static const size_t ArraySize = 5;
int array[ArraySize];
func(array, ArraySize);
Because the pointer contains no size information, you can't use sizeof.
void func(int* array) {
std::cout << sizeof(array) << "\n";
}
This will output the size of "int*" - which is 4 or 8 bytes depending on 32 vs 64 bits.
Instead you need to accept the size parameters
void func(int* array, size_t arraySize);
static const size_t ArraySize = 5;
int array[ArraySize];
func(array, ArraySize);
Even if you try to pass a fixed-sized array, it turns out this is syntactic sugar:
void func(int array[5]);
http://ideone.com/gaSl6J
Remember how I said that an array is NOT a pointer, just equivalent?
int array[5];
int* ptr = array;
std::cout << "array size " << sizeof(array) << std::endl;
std::cout << "ptr size " << sizeof(ptr) << str::endl;
array size will be 5 * sizeof(int) = 20
ptr size will be sizeof(int *) which will be either 4 or 8 bytes.
sizeof returns the size of the type being supplied, if you supply an object then it deduces the type and returns the size of that
If you want to know how many elements of an array are in the array, when you have the array and not a pointer, you can write
sizeof(array) / sizeof(array[0])
or
sizeof(array) / sizeof(*array)
There's no way to do that. This is one good reason (among many) to use vectors instead of arrays. But if you must use an array then you must pass the size of the array as a parameter to your function
int largest(int *list, int list_size, int highest_index)
Arrays in C++ are quite poor, the sooner you learn to use vectors the easier you will find things.
Pointers do not have information about the number of elements they refer to. If you are speaking about the first argument of the function call then if list is an array you can indeed use the syntax
sizeof( list ) / sizeof( int )
I would like to append that there are three approaches. The first one is to use arrays passed by reference. The second one is to use pointer to the first element and the number of elements. And the third one is to use two pointers - the start pointer and the last pointer as standard algorithms usually are defined. Character arrays have an additional possibility to process them.
The simple answer is you cannot. You need to store it in a variable. The great advantage with C++ is it has STL and you can use vector. size() method gives the size of the vector at that instant.
#include<iostream>
#include<vector>
using namespace std;
int main () {
vector<int> v;
for(int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << v.size() << endl;
for(int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << v.size() << endl;
return 0;
}
output:
10
20
Not tested. But, should work. ;)
You need to remember in a variable array size, there is no possibility to retrieve array size from pointer.
const int SIZE = 10;
int list[SIZE];
// or
int* list = new int[SIZE]; // do not forget to delete[]
My answer uses a char array instead of an integer array but I do hope it helps.
You can use a counter until you reach the end of the array. Char arrays always end with a '\0' and you can use that to check the end of the array is reached.
char array[] = "hello world";
char *arrPtr = array;
char endOfString = '\0';
int stringLength = 0;
while (arrPtr[stringLength] != endOfString) {
stringLength++;
}
stringLength++;
cout << stringLength << endl;
Now you have the length of the char array.
I tried the counting the number of integers in array using this method. Apparently, '\0' doesn't apply here obviously but the -1 index of the array is 0. So assuming that there is no 0, in the array that you are using. You can replace the '\0' with 0 in the code and change the code to use int pointers and arrays.
I am writing a simple function that returns the largest integer in an array. The problem I am having is finding the number of elements in the array.
Here is the function header:
int largest(int *list, int highest_index)
How can I get the number of integers in the array 'list'.
I have tried the following methods:
int i = sizeof list/sizeof(int); //returns incorrect value
int i = list.size(); // does not compile
Any help will be greatly appreciated!
C++ is based on C and inherits many features from it. In relation to this question, it inherits something called "array/pointer equivalence" which is a rule that allows an array to decay to a pointer, especially when being passed as a function argument. It doesn't mean that an array is a pointer, it just means that it can decay to one.
void func(int* ptr);
int array[5];
int* ptr = array; // valid, equivalent to 'ptr = &array[0]'
func(array); // equivalent to func(&array[0]);
This last part is the most relevant to your question. You are not passing the array, you are passing the address of the 0th element.
In order for your function to know how big the incoming array is, you will need to send that information as an argument.
static const size_t ArraySize = 5;
int array[ArraySize];
func(array, ArraySize);
Because the pointer contains no size information, you can't use sizeof.
void func(int* array) {
std::cout << sizeof(array) << "\n";
}
This will output the size of "int*" - which is 4 or 8 bytes depending on 32 vs 64 bits.
Instead you need to accept the size parameters
void func(int* array, size_t arraySize);
static const size_t ArraySize = 5;
int array[ArraySize];
func(array, ArraySize);
Even if you try to pass a fixed-sized array, it turns out this is syntactic sugar:
void func(int array[5]);
http://ideone.com/gaSl6J
Remember how I said that an array is NOT a pointer, just equivalent?
int array[5];
int* ptr = array;
std::cout << "array size " << sizeof(array) << std::endl;
std::cout << "ptr size " << sizeof(ptr) << str::endl;
array size will be 5 * sizeof(int) = 20
ptr size will be sizeof(int *) which will be either 4 or 8 bytes.
sizeof returns the size of the type being supplied, if you supply an object then it deduces the type and returns the size of that
If you want to know how many elements of an array are in the array, when you have the array and not a pointer, you can write
sizeof(array) / sizeof(array[0])
or
sizeof(array) / sizeof(*array)
There's no way to do that. This is one good reason (among many) to use vectors instead of arrays. But if you must use an array then you must pass the size of the array as a parameter to your function
int largest(int *list, int list_size, int highest_index)
Arrays in C++ are quite poor, the sooner you learn to use vectors the easier you will find things.
Pointers do not have information about the number of elements they refer to. If you are speaking about the first argument of the function call then if list is an array you can indeed use the syntax
sizeof( list ) / sizeof( int )
I would like to append that there are three approaches. The first one is to use arrays passed by reference. The second one is to use pointer to the first element and the number of elements. And the third one is to use two pointers - the start pointer and the last pointer as standard algorithms usually are defined. Character arrays have an additional possibility to process them.
The simple answer is you cannot. You need to store it in a variable. The great advantage with C++ is it has STL and you can use vector. size() method gives the size of the vector at that instant.
#include<iostream>
#include<vector>
using namespace std;
int main () {
vector<int> v;
for(int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << v.size() << endl;
for(int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << v.size() << endl;
return 0;
}
output:
10
20
Not tested. But, should work. ;)
You need to remember in a variable array size, there is no possibility to retrieve array size from pointer.
const int SIZE = 10;
int list[SIZE];
// or
int* list = new int[SIZE]; // do not forget to delete[]
My answer uses a char array instead of an integer array but I do hope it helps.
You can use a counter until you reach the end of the array. Char arrays always end with a '\0' and you can use that to check the end of the array is reached.
char array[] = "hello world";
char *arrPtr = array;
char endOfString = '\0';
int stringLength = 0;
while (arrPtr[stringLength] != endOfString) {
stringLength++;
}
stringLength++;
cout << stringLength << endl;
Now you have the length of the char array.
I tried the counting the number of integers in array using this method. Apparently, '\0' doesn't apply here obviously but the -1 index of the array is 0. So assuming that there is no 0, in the array that you are using. You can replace the '\0' with 0 in the code and change the code to use int pointers and arrays.