CODEWITHSUNDEEP
carrays
unj2
unj2

Reputation: 53481

How do you get the size of array that is passed into the function?

I am trying to write a function that prints out the elements in an array. However when I work with the arrays that are passed, I don't know how to iterate over the array.

void
print_array(int* b)
{
  int sizeof_b = sizeof(b) / sizeof(b[0]);
  int i;
  for (i = 0; i < sizeof_b; i++)
    {
      printf("%d", b[i]);
    }
}

What is the best way to do iterate over the passed array?

Upvotes: 16

Views: 21556

Answers (8)

Brian R. Bondy
Brian R. Bondy

Reputation: 347216

You need to also pass the size of the array to the function.
When you pass in the array to your function, you are really passing in the address of the first element in that array. So the pointer is only pointing to the first element once inside your function.

Since memory in the array is continuous though, you can still use pointer arithmetic such as (b+1) to point to the second element or equivalently b[1]

void print_array(int* b, int num_elements)
{
  for (int i = 0; i < num_elements; i++)
    {
      printf("%d", b[i]);
    }
}

This trick only works with arrays not pointers:

sizeof(b) / sizeof(b[0])

... and arrays are not the same as pointers.

Upvotes: 20

void
void

Reputation: 7880

The question has already some good answers, for example the second one. However there is a lack of explanation so I would like to extend the sample and explain it:

Using template and template parameters and in this case None-Type Template parameters makes it possible to get the size of a fixed array with any type.

Assume you have such a function template:

template<typename T, int S>
int getSizeOfArray(T (&arr)[S]) {
    return S;
}

The template is clearly for any type(here T) and a fixed integer(S). The function as you see takes a reference to an array of S objects of type T, as you know in C++ you cannot pass arrays to functions by value but by reference so the function has to take a reference.

Now if u use it like this:

int i_arr[] = { 3, 8, 90, -1 };
std::cout << "number f elements in Array: " << getSizeOfArray(i_arr) << std::endl;

The compiler will implicitly instantiate the template function and detect the arguments, so the S here is 4 which is returned and printed to output.

Upvotes: 0

Chris Tang
Chris Tang

Reputation: 574

Use variable to pass the size of array. int sizeof_b = sizeof(b) / sizeof(b[0]); does nothing but getting the pre-declared array size, which is known, and you could have passed it as an argument; for instance, void print_array(int*b, int size). size could be the user-defined size too.

int sizeof_b = sizeof(b) / sizeof(b[0]); will cause redundant iteration when the number of elements is less than the pre-declared array-size.

Upvotes: 0

Arun
Arun

Reputation: 20383

For C, you have to pass the length (number of elements)of the array.

For C++, you can pass the length, BUT, if you have access to C++0x, BETTER is to use std::array. See here and here. It carries the length, and provides check for out-of-bound if you access elements using the at() member function.

Upvotes: 2

Roman A. Taycher
Roman A. Taycher

Reputation: 19477

In c++ you can also use a some type of list class implemented as an array with a size method or as a struct with a size member(in c or c++).

Upvotes: 0

Tony Delroy
Tony Delroy

Reputation: 106086

You could try this...

#include <cstdio>                                                               

void 
print_array(int b[], size_t N) 
{ 
    for (int i = 0; i < N; ++i) 
        printf("%d ", b[i]);
    printf("\n");
}

template <size_t N>
inline void 
print_array(int (&b)[N]) 
{
    // could have loop here, but inline forwarding to
    // single function eliminates code bloat...
    print_array(b, N);
}                                                                                

int main()                                                                      
{                                                                               
    int a[] = { 1, 2 };                                                         
    int b[] = { };
    int c[] = { 1, 2, 3, 4, 5 };                                                

    print_array(a);                                                             
    // print_array(b);                                                          
    print_array(c);                                                             
}

...interestingly b doesn't work...

array_size.cc: In function `int main()':
array_size.cc:19: error: no matching function for call to `print_array(int[0u])'

JoshD points out in comments below the issue re 0 sized arrays (a GCC extension), and the size inference above.

Upvotes: 0

Chubsdad
Chubsdad

Reputation: 25497

Why don't you use function templates for this (C++)?

template<class T, int N> void f(T (&r)[N]){
}

int main(){
    int buf[10];
    f(buf);
}

EDIT 2:

The qn now appears to have C tag and the C++ tag is removed.

Upvotes: 5

Matt Joiner
Matt Joiner

Reputation: 118480

In C99, you can require that an array an array has at least n elements thusly:

void print_array(int b[static n]);

6.7.5.3.7: A declaration of a parameter as ‘‘array of type’’ shall be adjusted to ‘‘qualified pointer to type’’, where the type qualifiers (if any) are those specified within the [ and ] of the array type derivation. If the keyword static also appears within the [ and ] of the array type derivation, then for each call to the function, the value of the corresponding actual argument shall provide access to the first element of an array with at least as many elements as specified by the size expression.

In GCC you can pass the size of an array implicitly like this:

void print_array(int n, int b[n]);

Upvotes: 0

Related Questions