Passing an array as argument to a function

Calin Negru

float* p;
now you can access it as an array
p[0] = 5.0;
p[100] = 10.0;

I understand "p[0] = 5.0;" since that`s the first element, but then "p[100] = 10.0;" don`t you need to alocate first "p = new float[101]"

Lost User

The documentation on MSDN (_countof Macro | Microsoft Docs[^]) does not identify it as MS only.

Greg Utas

Right you are! I forget to remove the *.

Robust Services Core | Software Techniques for Lemmings | Articles

Greg Utas

I made a mistake. See Richard's post below.

Robust Services Core | Software Techniques for Lemmings | Articles

Calin Negru

noticed

Lost User

Why not leave the * but remove the []? The parameter is a pointer to an array, not an actual array.

Greg Utas

I use brackets to indicate that the underlying is an array, not a pointer to a single char. Maybe it's because I was a latecomer to C++ and never used C idioms, another one being if(p), for which I write if(p != nullptr).

Robust Services Core | Software Techniques for Lemmings | Articles

Lost User

A pointer rarely means a pointer to a single item, it always indicates a pointer to a set of items. If you want to pass a single int, char etc, then why use a pointer? I would agree with you on using the if(p != nullptr) construct, it makes it much clearer.

Greg Utas

Richard MacCutchan wrote:

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

Because it might inadvertently be nullptr, and I find this defensive code jarring:

void f(type& t)
{
if(&t ! nullptr)...
}

The optimize-everything crowd won't agree, but in my opinion code that invokes the above with a null reference should suffer a SIGSEGV before the function is called. But since that's not the case...

Robust Services Core | Software Techniques for Lemmings | Articles

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