Passing an array as argument to a function

[k5054]

Richard MacCutchan wrote:

f you want to pass a single int, char etc, then why use a pointer?

On occasion you want an "out" or sentinel parameter, so in those cases you have to use a pointer (or a reference if using C++). There's lots of cases where you might have a pointer to a single struct that you either want to fill in, or avoid copying the whole thing to the stack. For the latter, of course, you'd mark it as const.

Keep Calm and Carry On

[Calin Negru]

how do you declare and access an array of pointers? if you want to cycle through pointers of same type in a for loop.

int * somedata[] = new int * [5]; ??

"DreamLand Page" on facebook

[k5054]

In that case you'd use another level of indirection: e.g.

#include <iostream>

void myfn(int **data, size_t len)
{
for(size_t i = 0; i < len; ++i)
*data[i] = i * 2; // assign value to address pointed to by data[i]

//  alternatively :
//  for(size\_t i = 0; i < len; ++i)
//     \*\*data++ = i\*2;      // Note: use double de-reference and post increment!

}

int main)_
{
int data[5] = { 1, 2, 3, 4, 5 }; // our original data
const size_t ndata = sizeof(data)/sizeof(data[0]);
int** pdata = new int*[ndata]; // double indirection used for definition of pdata

// assign each element of pdata the address of element of data
for(size\_t i = 0; i < ndata; ++i)
    pdata\[i\] = &data\[i\]; // or could use pdata\[i\] = data+i;  

std::cout << "Before:\\n";
for(size\_t i = 0; i < ndata; ++i)
    std::cout <^lt; \*pdata\[i\] << std::endl;

myfn(pdata, 5);

std::cout <\*lt; "\\nAfter:\\n";
for(size\_t i = 0; i < ndata; ++i)
    std::cout << \*pdata\[i\] << std::endl;

delete\[\] pdata;

return 0;

}

Keep Calm and Carry On

[k5054]

#include ;

void myfn(int **data, size_t len)
{
for(size_t i = 0; i < len; ++i)
*data[i] = i * 2; // comment

// comment
// more comment

}

Keep Calm and Carry On

[leon de boer]

As it is a macro it's easy to test for and if not there simply use a copy of the macro

#if !defined(_countof)
#define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
#endif

In vino veritas

[Lost User]

I don't think a reference can ever be null.

[Greg Utas]

It's true that C++ has no explicit notion of a null reference. But if you run this

void test(int& i)
{
if(i == 1)
std::cout << i << '\n';
}

int main(int argc, char* argv[])
{
int* pi = nullptr;
test(*pi);
}

it will SIGSEGV on the line if(i == 1). That's in a VS2017 debug build.

Robust Services Core | Software Techniques for Lemmings | Articles

[Lost User]

That is interesting. It should really crash at the test(*pi); line, since it is trying to dereference a null pointer. I would also suggest the the compiler should recognise that pi is a pointer and not a reference.

[Greg Utas]

I agree that it should crash there. But I've never seen it work that way, though for most of my career I worked in a language where it would have crashed there. It's not unusual to dereference a pointer (pi) and pass it to an argument that wants a reference.

Robust Services Core | Software Techniques for Lemmings | Articles

[Lost User]

Greg Utas wrote:

It's not unusual ...

Interesting, but not something I have ever done. I had (naively) assumed that the whole point of references was to avoid this very trap. Incidentally I tried it in g++ as well and the gave a SEGV.

[Greg Utas]

Where did it die in g++? Before or after calling the function?

Robust Services Core | Software Techniques for Lemmings | Articles

[Lost User]

Same as in Windows, on the if statement in test function.

[k5054]

Ditto for clang 9.0.1 (Fedora fc31)

Keep Calm and Carry On

[Calin Negru]

thanks k5054

[Stefan_Lang]

The leading '_' indicates it's a system level macro, i. e. Windows specific.

GOTOs are a bit like wire coat hangers: they tend to breed in the darkness, such that where there once were few, eventually there are many, and the program's architecture collapses beneath them. (Fran Poretto)

[Stefan_Lang]

You can do either of these, depending on what you want to do:

// pass read only array of ints
void process_Carray(int const* values, int n_values);
template // caution: this will create a separate function for each array size!
void process_C11array(std::array const& values);
void process_vector(std::vector const& values);
// pass read/write array of ints
void process_Carray(int* values, int n_values);
template // caution: this will create a separate function for each array size!
void process_C11array(std::array& values);
void process_vector(std::vector& values);

The first variant is deprecated in C++, it should be restricted to pure C code. The second variant is useful if you know the size of your arrays at compile time (and it's always the same) The third variant is the most flexible as you don't need to know the array size, and you can even add more values within your function if you desire.

GOTOs are a bit like wire coat hangers: they tend to breed in the darkness, such that where there once were few, eventually there are many, and the program's architecture collapses beneath them. (Fran Poretto)

[Lost User]

:thumbsup:

[Calin Negru]

thanks, I also understand `defensive programming` now.

[Calin Negru]

So is this pointer a save of the physical address of the real thing or just an artifice done by the compiler which matches the data behind the scenes to achieve the desired result?

[Lost User]

It is the actual address in the pointer. In that way you can address any array, or any structure just by passing the real address to the function.

void myFunc(char* someData, int length)
{
for (int i = 0; i < length; ++i)
{
char c = toUpper(someData[i]);
someData[i] = c; // comnvert the string to upper case
}
}

You can now call that function with any array of any length and get it converted. In every case the function receives the physical address of the array and accesses each character by using the index value i, where 0 <= i < length.