Velocity Reviews

Velocity Reviews (http://www.velocityreviews.com/forums/index.php)
-   C++ (http://www.velocityreviews.com/forums/f39-c.html)
-   -   Problem understanding pass by value and pass by reference of arrays and what happens in the memory (http://www.velocityreviews.com/forums/t541565-problem-understanding-pass-by-value-and-pass-by-reference-of-arrays-and-what-happens-in-the-memory.html)

venkatagmail 10-02-2007 11:26 PM

Problem understanding pass by value and pass by reference of arrays and what happens in the memory
 
I have problem understanding pass by value and pass by reference and
want to how how they are or appear in the memory:

I had to get my basics right again. I create an array and try all
possible ways of passing an array. In the following code, fun1(int
a1[]) - same as fun1(int* a1) - where both are of the type passed by
reference. Inside this function, another pointer a1 is created whose
address &a1 is different from that of the passed array a, which is &a
in the main method. However, the addresses of a[0] and a[1] in the
caller or main function are same as those of the array a1[0] and a1[1]
in the called function fun1(int a1[]). Any modifications to the array
in this function will reflect in the main method. How and where are
these variables created in stack, heap, tables and what happens after
and before calling the function?

Lets look at the other function fun2(int *&a2) where I am trying to
again pass by reference, but this time I do not want to create another
pointer but directly work on the original pointer pointing to the
array. When I pass this array a to this function it returns the
following error which I did not understand

fun2(a); // ERROR: invalid initialization of non-const reference of
//type 'int*&' from a temporary of type 'int*'

however, if I create another pointer int *aPtr = a; and then pass it
as fun2(aPtr); it works fine. Also in this case, I am working directly
with aPtr in both caller(main) and called (fun2) methods. i.e., &aPtr
is same in the caller and called functions, &a2 in fun2(int* &a2),
unlike the previous case, even this is pass by reference. I did not
have time to figure out the problem, so I am posting it here for
discussion and would like to know the details, as to how these
variables are created or assigned in memory.


#include<iostream>
using namespace std;

void fun1(int a1[]) // same as fun(int* p)
{
cout << "In fun(int a1[]) " << "a1 " << a1 << " &a1 " << &a1 << "
&a1[0] " << &a1[0] << endl;
// int a1[] is in a different location (different &a) but has the
// correct addresses of a1[0] and a1[1]
a1[0] = 10;
a1[1] = 20;
}

void fun2(int* &a2)
{
cout << "In fun1(int* &a2) " << " a2 " << a2 << " &a2 " << &a2 << "
&a2[0] " << &a2[0] << endl;
a2[0] = 30;
a2[1] = 50;
}

int main()
{
int a[2] = {0,1};
cout << "Main: a " << a << " &a " << &a << " &a[0] " << &a[0] <<
endl;

//fun2(a); // ERROR: invalid initialization of non-const
reference of
//type 'int*&' from a temporary of type 'int*'
fun1(a);
cout << "After fun(a): " << a[0] << ' ' << a[1] << endl;

int *aPtr = a;
cout << "Passing aPtr whose &aPtr " << &aPtr << " aPtr " << aPtr
<< endl;
fun2(aPtr); // Here it is ok, you can also use it as fun1(aPtr)
cout << "After fun1(aPtr): " << a[0] << ' ' << a[1] << endl;

int cInt = 10;
//int* &cPtr = &cInt; // WRONG:logically wrong as you are trying
to create a
// non-const reference of type int* & from
a
// temporary of type int*
int* cPtr = &cInt; // store the address of cInt in cPtr
int* &cRefPtr = cPtr; // make a reference of the cPtr

}

output:

Main: a 0x22ff80 &a 0x22ff80 &a[0] 0x22ff80
In fun(int a1[]) a1 0x22ff80 &a1 0x22feb0 &a1[0] 0x22ff80
After fun(a): 10 20
Passing aPtr whose &aPtr 0x22ff7c aPtr 0x22ff80
In fun1(int* &a2) a2 0x22ff80 &a2 0x22ff7c &a2[0] 0x22ff80
After fun1(aPtr): 30 50


Jim Langston 10-03-2007 12:59 AM

Re: Problem understanding pass by value and pass by reference of arrays and what happens in the memory
 
"venkatagmail" <chikkubhai@gmail.com> wrote in message
news:1191367573.538535.200570@22g2000hsm.googlegro ups.com...
>I have problem understanding pass by value and pass by reference and
> want to how how they are or appear in the memory:
>
> I had to get my basics right again. I create an array and try all
> possible ways of passing an array. In the following code, fun1(int
> a1[]) - same as fun1(int* a1) - where both are of the type passed by
> reference. Inside this function, another pointer a1 is created whose
> address &a1 is different from that of the passed array a, which is &a
> in the main method. However, the addresses of a[0] and a[1] in the
> caller or main function are same as those of the array a1[0] and a1[1]
> in the called function fun1(int a1[]). Any modifications to the array
> in this function will reflect in the main method. How and where are
> these variables created in stack, heap, tables and what happens after
> and before calling the function?
>
> Lets look at the other function fun2(int *&a2) where I am trying to
> again pass by reference, but this time I do not want to create another
> pointer but directly work on the original pointer pointing to the
> array. When I pass this array a to this function it returns the
> following error which I did not understand
>
> fun2(a); // ERROR: invalid initialization of non-const reference of
> //type 'int*&' from a temporary of type 'int*'
>
> however, if I create another pointer int *aPtr = a; and then pass it
> as fun2(aPtr); it works fine. Also in this case, I am working directly
> with aPtr in both caller(main) and called (fun2) methods. i.e., &aPtr
> is same in the caller and called functions, &a2 in fun2(int* &a2),
> unlike the previous case, even this is pass by reference. I did not
> have time to figure out the problem, so I am posting it here for
> discussion and would like to know the details, as to how these
> variables are created or assigned in memory.
>
>
> #include<iostream>
> using namespace std;
>
> void fun1(int a1[]) // same as fun(int* p)
> {


a1 is a local variable who's contents will be a pointer that is passed in.

> cout << "In fun(int a1[]) " << "a1 " << a1 << " &a1 " << &a1 << "
> &a1[0] " << &a1[0] << endl;


Outputting a1 will output the contents of it, which is the pointer passed
in, which points to the array a declared in main.
Ouputting &a1 will output the address of the local pointer which is stored
on the stack/heap.
Outputting &a1[0] will output the address of the first int that a1 points
to, which is the same as a1 itself.

Lets presume a 4 byte int. When this function is called 4 bytes are set
aside to hold the paramater a1 (or sizeof int*). Those 4 bytes can be
anywhere in memory where the heap is (I believe compilers are free to use
anywhere, heap is most common. I may be wrong on if they are free to use
wherever or not. I don't have copy of standard). In your case it is memory
locatoin 0x22feb0 to 0x22feb3. When this function is called and you pass
the parameter of the pointer that pointer is pushed onto the stack. The
function is called. The value is popped off and copied into the location of
the local variable a1 (0x22feb0 to 0x22feb3). These 4 bytes in your case
consist of the pointer value 0x22ff80.

Now, if you look at the address of the variable a1 you will get 0x22f3b3.
If you look at it's contents you will get 0x22ff80. If you dereference it
(look at where the pointer is pointing to) you'll get the values in the
array. Which is why &a1[0] returns the address of the original array.
a1[0] says look at the 0th element of where the pointer is pointing to. &
means get the address of it.

Compilers are free to do somethings diffrent, I'm not aware of what they're
allowed and not allowed to do different, but passing pointers is generally
handled this way.

> // int a1[] is in a different location (different &a) but has the
> // correct addresses of a1[0] and a1[1]
> a1[0] = 10;
> a1[1] = 20;
> }
>
> void fun2(int* &a2)
> {
> cout << "In fun1(int* &a2) " << " a2 " << a2 << " &a2 " << &a2 << "
> &a2[0] " << &a2[0] << endl;
> a2[0] = 30;
> a2[1] = 50;
> }
>
> int main()
> {
> int a[2] = {0,1};
> cout << "Main: a " << a << " &a " << &a << " &a[0] " << &a[0] <<
> endl;
>
> //fun2(a); // ERROR: invalid initialization of non-const
> reference of
> //type 'int*&' from a temporary of type 'int*'
> fun1(a);
> cout << "After fun(a): " << a[0] << ' ' << a[1] << endl;
>
> int *aPtr = a;
> cout << "Passing aPtr whose &aPtr " << &aPtr << " aPtr " << aPtr
> << endl;
> fun2(aPtr); // Here it is ok, you can also use it as fun1(aPtr)
> cout << "After fun1(aPtr): " << a[0] << ' ' << a[1] << endl;
>
> int cInt = 10;
> //int* &cPtr = &cInt; // WRONG:logically wrong as you are trying
> to create a
> // non-const reference of type int* & from
> a
> // temporary of type int*
> int* cPtr = &cInt; // store the address of cInt in cPtr
> int* &cRefPtr = cPtr; // make a reference of the cPtr
>
> }
>
> output:
>
> Main: a 0x22ff80 &a 0x22ff80 &a[0] 0x22ff80
> In fun(int a1[]) a1 0x22ff80 &a1 0x22feb0 &a1[0] 0x22ff80
> After fun(a): 10 20
> Passing aPtr whose &aPtr 0x22ff7c aPtr 0x22ff80
> In fun1(int* &a2) a2 0x22ff80 &a2 0x22ff7c &a2[0] 0x22ff80
> After fun1(aPtr): 30 50
>




venkatagmail 10-03-2007 01:43 AM

Re: Problem understanding pass by value and pass by reference of arrays and what happens in the memory
 
Thank you, as far as I understand from yours, correct me when I go
wrong.

when I start off with my declaration of an array 'a' in main(), they
are created in the heap?, with a[0] ,a[1] pointing to my first and
second elements of array a. The value of a contains the address of
a[0] using which I use to pass as a pointer to an int to fun1(int
a1[]). Before I call this function, all of my automatic variables move
into stack and the address of the caller function is stored at the top
of the stack to be returned to the operating system I believe?

Once I enter the called method fun1(int a1[]) I have access to the
first location of the array which is a[0] (which is already pushed
into stack??) now stored in a1 (a1 is in a different location in
heap), so once I make modifications to a1[0], am I making
modifications to the original value in stack?? (which I know cannot be
modified directly) or are these modified only after I exit the
function fun1, which however is doubtful as a1[0], a1[1] and a[0],
a[1] point to same address locations. I am confused how the memory
thing takes place in case of pass by value, pass by reference using
pointer and using a reference. This is just the beginning of my
problem in understanding memory assignments. The original problem I
posted above has lot more to ask.


Barry 10-03-2007 02:17 AM

Re: Problem understanding pass by value and pass by reference ofarrays and what happens in the memory
 
venkatagmail wrote:
> I have problem understanding pass by value and pass by reference and
> want to how how they are or appear in the memory:
>
> I had to get my basics right again. I create an array and try all
> possible ways of passing an array. In the following code, fun1(int
> a1[]) - same as fun1(int* a1) - where both are of the type passed by
> reference. Inside this function, another pointer a1 is created whose
> address &a1 is different from that of the passed array a, which is &a
> in the main method. However, the addresses of a[0] and a[1] in the
> caller or main function are same as those of the array a1[0] and a1[1]
> in the called function fun1(int a1[]). Any modifications to the array
> in this function will reflect in the main method. How and where are
> these variables created in stack, heap, tables and what happens after
> and before calling the function?
>
> Lets look at the other function fun2(int *&a2) where I am trying to
> again pass by reference, but this time I do not want to create another
> pointer but directly work on the original pointer pointing to the
> array. When I pass this array a to this function it returns the
> following error which I did not understand
>
> fun2(a); // ERROR: invalid initialization of non-const reference of
> //type 'int*&' from a temporary of type 'int*'


a is of array type, which is bound to a fixed address. so you can't
change a to point to another one. when you pass an array as a parameter
for a function, here a decays to type /int* const/, so you can convert
it to /int*&/.

>
> however, if I create another pointer int *aPtr = a; and then pass it


conversion from /int* const/ to /int*/ is allowed, /aPtr/ points to
where /a/ points, but /aPtr/ has no way modify where /a/ points to.
this is just like:

const int S = 100;
int i = S;

> as fun2(aPtr); it works fine. Also in this case, I am working directly
> with aPtr in both caller(main) and called (fun2) methods. i.e., &aPtr
> is same in the caller and called functions, &a2 in fun2(int* &a2),
> unlike the previous case, even this is pass by reference. I did not
> have time to figure out the problem, so I am posting it here for
> discussion and would like to know the details, as to how these
> variables are created or assigned in memory.


To understand these, you have learn how to find where the constness lays.

as /aPtr/ is typeof 'int*' not 'int* const', then you can have /aPtr/
point to anywhere of 'int' type, and of cause NOT to 'const int', as we
can modify the content where /aPtr/ points to.

>
>
> #include<iostream>
> using namespace std;
>
> void fun1(int a1[]) // same as fun(int* p)
> {
> cout << "In fun(int a1[]) " << "a1 " << a1 << " &a1 " << &a1 << "
> &a1[0] " << &a1[0] << endl;
> // int a1[] is in a different location (different &a) but has the
> // correct addresses of a1[0] and a1[1]
> a1[0] = 10;
> a1[1] = 20;
> }
>
> void fun2(int* &a2)
> {
> cout << "In fun1(int* &a2) " << " a2 " << a2 << " &a2 " << &a2 << "
> &a2[0] " << &a2[0] << endl;
> a2[0] = 30;
> a2[1] = 50;
> }
>
> int main()
> {
> int a[2] = {0,1};
> cout << "Main: a " << a << " &a " << &a << " &a[0] " << &a[0] <<
> endl;
>
> //fun2(a); // ERROR: invalid initialization of non-const
> reference of
> //type 'int*&' from a temporary of type 'int*'
> fun1(a);
> cout << "After fun(a): " << a[0] << ' ' << a[1] << endl;
>
> int *aPtr = a;
> cout << "Passing aPtr whose &aPtr " << &aPtr << " aPtr " << aPtr
> << endl;
> fun2(aPtr); // Here it is ok, you can also use it as fun1(aPtr)
> cout << "After fun1(aPtr): " << a[0] << ' ' << a[1] << endl;
>
> int cInt = 10;
> //int* &cPtr = &cInt; // WRONG:logically wrong as you are trying
> to create a
> // non-const reference of type int* & from
> a
> // temporary of type int*
> int* cPtr = &cInt; // store the address of cInt in cPtr
> int* &cRefPtr = cPtr; // make a reference of the cPtr
>
> }
>
> output:
>
> Main: a 0x22ff80 &a 0x22ff80 &a[0] 0x22ff80
> In fun(int a1[]) a1 0x22ff80 &a1 0x22feb0 &a1[0] 0x22ff80
> After fun(a): 10 20
> Passing aPtr whose &aPtr 0x22ff7c aPtr 0x22ff80
> In fun1(int* &a2) a2 0x22ff80 &a2 0x22ff7c &a2[0] 0x22ff80
> After fun1(aPtr): 30 50
>



venkatagmail 10-03-2007 04:22 AM

Re: Problem understanding pass by value and pass by reference of arrays and what happens in the memory
 
>>>"a is of array type, which is bound to a fixed address. so you can't
change a to point to another one. when you pass an array as a
parameter
for a function, here a decays to type /int* const/, so you can convert
it to /int*&/."<<<

Barry, do you suggest that, I can convert array a bound to fixed
address which decays to /int* const/ to type /int*&/ ??

i.e., if I create an array int a[] = {1,2}; it is bound to a fixed
address. If I pass it to a function fun2(int *&a2) it gives me an
error!! Whereas I create another ptr /int* aPtr = a/, I can then pass
it as this can now point to any integer and is not a constant value?

>>>"conversion from /int* const/ to /int*/ is allowed, /aPtr/ points to

where /a/ points, but /aPtr/ has no way modify where /a/ points to.
this is just like:"<<<

In line with what you said above, you say that I can create a pointer
\int* aPtr = a;\ but you also say there is no way to modify where \a\
points to?? But I can modify the contents of \a\ using the \aPtr\
right or am I getting a wrong message here??

What about the memory contents and how these are allocated for the
three types of passing input arguments fun1(int a1[]) or fun1(int *a1)
and fun2(int *&a2) ?? how different are these in terms how memory is
allocated and assigned?


Barry 10-03-2007 04:50 AM

Re: Problem understanding pass by value and pass by reference ofarrays and what happens in the memory
 
venkatagmail wrote:
>>>> "a is of array type, which is bound to a fixed address. so you can't

> change a to point to another one. when you pass an array as a
> parameter
> for a function, here a decays to type /int* const/, so you can convert
> it to /int*&/."<<<
>
> Barry, do you suggest that, I can convert array a bound to fixed
> address which decays to /int* const/ to type /int*&/ ??
>
> i.e., if I create an array int a[] = {1,2}; it is bound to a fixed
> address. If I pass it to a function fun2(int *&a2) it gives me an
> error!! Whereas I create another ptr /int* aPtr = a/, I can then pass
> it as this can now point to any integer and is not a constant value?
>
>>>> "conversion from /int* const/ to /int*/ is allowed, /aPtr/ points to

> where /a/ points, but /aPtr/ has no way modify where /a/ points to.
> this is just like:"<<<
>
> In line with what you said above, you say that I can create a pointer
> \int* aPtr = a;\ but you also say there is no way to modify where \a\
> points to?? But I can modify the contents of \a\ using the \aPtr\


*where* /a/ points to can't be modified,
*what* /a/ points to can be modified.

int* aPtr = a;
then you can modify *what* /a/ points to, /aPtr/ works just like a proxy;

also, you can modify /aPtr/ to point to somewhere else like:

int b[] = {1, 2};
aPtr = b;
now /aPtr/ is a proxy of /b/;

> right or am I getting a wrong message here??
>
> What about the memory contents and how these are allocated for the
> three types of passing input arguments fun1(int a1[]) or fun1(int *a1)
> and fun2(int *&a2) ?? how different are these in terms how memory is
> allocated and assigned?
>


Sorry.
I think my words are not enough to explain these to you.

see this example please.

#include <iostream>
#include <cstddef> // NULL

void print(const int* a, int count)
{
for (int i = 0; i < count; ++i)
std::cout << a[i] << ' ';
std::cout << std::endl;
}

void f1(int a[], int count) // == void f1(int* a, int count)
{
a[0] = 100; // modify WHAT a points to
a = NULL; // a points to NULL (WHERE)
print(a, count);
}

void f2(int* a, int count)
{
a[1] = 200;
a = NULL;
print(a, count);
}

int main()
{
int a[] = {1, 2, 3, 4};
print(a, 4);
f1(a, 4);
f2(a, 4);
print(a, 4);
}

Barry 10-03-2007 04:52 AM

Re: Problem understanding pass by value and pass by reference ofarrays and what happens in the memory
 
Barry wrote:
> venkatagmail wrote:
>>>>> "a is of array type, which is bound to a fixed address. so you can't

>> change a to point to another one. when you pass an array as a
>> parameter
>> for a function, here a decays to type /int* const/, so you can convert
>> it to /int*&/."<<<
>>
>> Barry, do you suggest that, I can convert array a bound to fixed
>> address which decays to /int* const/ to type /int*&/ ??
>>
>> i.e., if I create an array int a[] = {1,2}; it is bound to a fixed
>> address. If I pass it to a function fun2(int *&a2) it gives me an
>> error!! Whereas I create another ptr /int* aPtr = a/, I can then pass
>> it as this can now point to any integer and is not a constant value?
>>
>>>>> "conversion from /int* const/ to /int*/ is allowed, /aPtr/ points to

>> where /a/ points, but /aPtr/ has no way modify where /a/ points to.
>> this is just like:"<<<
>>
>> In line with what you said above, you say that I can create a pointer
>> \int* aPtr = a;\ but you also say there is no way to modify where \a\
>> points to?? But I can modify the contents of \a\ using the \aPtr\

>
> *where* /a/ points to can't be modified,
> *what* /a/ points to can be modified.
>
> int* aPtr = a;
> then you can modify *what* /a/ points to, /aPtr/ works just like a proxy;
>
> also, you can modify /aPtr/ to point to somewhere else like:
>
> int b[] = {1, 2};
> aPtr = b;
> now /aPtr/ is a proxy of /b/;
>
>> right or am I getting a wrong message here??
>>
>> What about the memory contents and how these are allocated for the
>> three types of passing input arguments fun1(int a1[]) or fun1(int *a1)
>> and fun2(int *&a2) ?? how different are these in terms how memory is
>> allocated and assigned?
>>

>
> Sorry.
> I think my words are not enough to explain these to you.
>
> see this example please.
>
> #include <iostream>
> #include <cstddef> // NULL
>
> void print(const int* a, int count)
> {
> for (int i = 0; i < count; ++i)
> std::cout << a[i] << ' ';
> std::cout << std::endl;
> }
>
> void f1(int a[], int count) // == void f1(int* a, int count)
> {
> a[0] = 100; // modify WHAT a points to


oops:

> a = NULL; // a points to NULL (WHERE)
> print(a, count);


print(a, count);
a = NULL;
> }
>
> void f2(int* a, int count)
> {
> a[1] = 200;
> a = NULL;
> print(a, count);


print(a, count);
a = NULL;

> }
>
> int main()
> {
> int a[] = {1, 2, 3, 4};
> print(a, 4);
> f1(a, 4);
> f2(a, 4);
> print(a, 4);
> }


venkatagmail 10-03-2007 08:34 AM

Re: Problem understanding pass by value and pass by reference of arrays and what happens in the memory
 
Thank you Barry for making me realize the problem of const and non-
const reference and pointers. I wished I also understood how the
memory is allocated in detail when calling these different methods.
I have problems understanding linked lists where I pass a head node
pointer by value and by reference. In either case I am able to access
the all the subsequent nodes until the end of the list, delete and
make modifications to them in the called function. I still want to
understand these things in terms of the memory allocation and
deallocation in heap and stack.


Jim Langston 10-03-2007 08:57 AM

Re: Problem understanding pass by value and pass by reference of arrays and what happens in the memory
 
"venkatagmail" <chikkubhai@gmail.com> wrote in message
news:1191385320.841069.158900@n39g2000hsh.googlegr oups.com...
>>>>"a is of array type, which is bound to a fixed address. so you can't

> change a to point to another one. when you pass an array as a
> parameter
> for a function, here a decays to type /int* const/, so you can convert
> it to /int*&/."<<<
>
> Barry, do you suggest that, I can convert array a bound to fixed
> address which decays to /int* const/ to type /int*&/ ??
>
> i.e., if I create an array int a[] = {1,2}; it is bound to a fixed
> address. If I pass it to a function fun2(int *&a2) it gives me an
> error!! Whereas I create another ptr /int* aPtr = a/, I can then pass
> it as this can now point to any integer and is not a constant value?
>
>>>>"conversion from /int* const/ to /int*/ is allowed, /aPtr/ points to

> where /a/ points, but /aPtr/ has no way modify where /a/ points to.
> this is just like:"<<<
>
> In line with what you said above, you say that I can create a pointer
> \int* aPtr = a;\ but you also say there is no way to modify where \a\
> points to?? But I can modify the contents of \a\ using the \aPtr\
> right or am I getting a wrong message here??
>
> What about the memory contents and how these are allocated for the
> three types of passing input arguments fun1(int a1[]) or fun1(int *a1)
> and fun2(int *&a2) ?? how different are these in terms how memory is
> allocated and assigned?


There is no differnce. In all cases an address is pushed onto the stack and
popped off by the function. It's just how the compiler treates them that is
different.



Barry 10-03-2007 09:00 AM

Re: Problem understanding pass by value and pass by reference ofarrays and what happens in the memory
 
venkatagmail wrote:
> Thank you Barry for making me realize the problem of const and non-
> const reference and pointers. I wished I also understood how the
> memory is allocated in detail when calling these different methods.
> I have problems understanding linked lists where I pass a head node
> pointer by value and by reference. In either case I am able to access


pass by reference IIF you create the list inside the function body,
then you assign the "created pointer to root" to the passed in
reference, then the function caller gain the side-effect, the passed in
parameter then points to the created list. after calling the function.

in C, we often use pointer to pointer for this goal.

> the all the subsequent nodes until the end of the list, delete and
> make modifications to them in the called function. I still want to
> understand these things in terms of the memory allocation and
> deallocation in heap and stack.
>


When accessing modifying the list you can only pass in the pointer to
the list only. As you don't change the passed in pointer to point to
another list(actually a node).


I have an idea for you,
You can use a debugger, like Visual C++, then you can see the the object
lays and how. Pay attention to when/what the variable is
assigned/initialized.

on reference, it's special, you can jump to the assembly code.
I was told that VC uses pointer-like stuff to implement it.

http://www.parashift.com/c++-faq-lite/references.html

TC++PL:
"In some cases, the compiler can optimize away a reference so that there
is no object representing that reference at runtime."

Reference is special, remember.


Here is exmaple when reference to pointer is used:

#include <iostream>
#include <cstddef> // NULL

int g_arr[] = {1, 2, 3};

void get_array(int*& arr, int& count)
{
arr = g_arr;
count = 3;
}

void print(const int* a, int count)
{
for (int i = 0; i < count; ++i)
std::cout << a[i] << ' ';
std::cout << std::endl;
}

int main()
{
int count = 0;
int* pi = NULL;
get_array(pi, count);
print(pi, count);
}



All times are GMT. The time now is 11:39 PM.

Powered by vBulletin®. Copyright ©2000 - 2014, vBulletin Solutions, Inc.
SEO by vBSEO ©2010, Crawlability, Inc.