What C# type stands for C++ float*?

Question

i have a function which is called from a library in C++ that has been imported to a C# project

I think it is asking for a pointer to an array. But I'm not sure how to make it work.

here is what it is asking for function(float*, float*);

but if i do something like

float[] f = {};
float[] f1 = {};

function(f,f1);

it says there are invalid arguments.

Answer 1

float * is a float pointer type in C#.

If the function is expecting float pointer arguments (float *), then the function must be presumed to work on pointers, possibly involving pointer arithmetic. It is therefore important to preserve that signature.

To pass float arrays in C# as float pointers (float*), you need to pin/fix the arrays in memory in an unsafe context to acquire a pointer to them that you can pass to the function to preserve its functionality:

unsafe
{
    fixed (float* ptr_f = f) //or equivalently "... = &f[0]" address of f[0]
    fixed (float* ptr_f2 = f2) //or equivalently "... = &f2[0]" address of f2[0]
    {
        function( ptr_f, ptr_f2 );
    }
}

You will also need to mark your assembly as unsafe (in project properties > build tab > allow unsafe code checkbox).

Answer 2

If this is a method imported via DLLImport() you can simply replace the array pointers with the typed array.

So a signature:

[DLLImport("some.dll")]
SomeMethod(int* a, float* b)

Becomes

[DLLImport("some.dll")]
SomeMethod(int[] a, float[] b)

Please note that this assumes the original c/c++ method was expecting an array. This won't work if the pointers are not intended to reference arrays.

Answer 3

You need to know exactly what the invoked C++ function is expecting.

In C (and C++) all of these function signatures are for all intents and purposes exactly the same:

void foo( float *x   , float *y   ) ;
void foo( float *x   , float  y[] ) ;
void foo( float  x[] , float *y   ) ;
void foo( float  x[] , float  y[] ) ;

All of them take 2 arguments, each of which contains is a pointer to (contains the address of) a variable of type float. And all of these expressions are exactly identical in C/C++:

float x[] ;
float *y  ;

float r1 = *(x+37) ; // all evaluate to the zero-relative
float r2 = x[37]   ; // 37th element of the array.
float r3 = *(y+37) ;
float r4 = y[37]   ;

• The expression *x says, "Fetch the float (4 bytes) located at the address contained in x.
• The expression *(x+n), where n is an integer value, says "Take the address contained in x, and to that add the offset in bytes obtained by the expression sizeof(float) * n. Fetch the float value located at the resulting address.
• The array expression x[n] is exactly equivalent to the pointer expression *(x+n).

And since arrays in C/C++ do not have any associated metadata describing their size, you need to know exactly what the called function is expecting.

Commonly, one passes a pointer (call by reference) in order to allow the caller to de-reference the point and set a value for you — the equivalent of C#'s ref and out keywords:

float x ;
float y ;
Foo( ref x , ref y ) ; // the callee MAY, but is not REQUIRED to set a value before returning to the caller.
Bar( out x , out y ) ; // the callee MUST set a value before returning to the caller.

The idiom your function is using is always used to locate an array, though typically, one also passes a size:

void foo( float *array , int array_length ) ;

Although is it not unusual, if the function is expecting the array to be a list of non-zero numeric values to be something like a C-style, NUL-terminated string. Given the function signature, for instance:

float compute_mean( float *Xs ) ;

It's not unusual for it to be expected to be invoked thus:

float Xs[] = { 3.0 , 2.5 , 9.8 , 7,5 , 0 , } ;
float mean = compute_mean( Xs ) ;

and the definition to be something like:

float compute_mean( float *Xs )
{
  float n   = 0.0 ;
  float sum = 0.0 ;
  float mean ;
  while ( *p )
  {
    ++n ;
    sum += *p++ ;
  }
  mean = n > 0 ? sum / n : 0.0 ;
  return mean ;
}

So you need to know the semantics of the method you're invoking.

Hope this helps.

Answer 4

that does not work at all in C#, when importing C / C++ libraries in C# you should use IntPtr instead of float*, see here for some examples: float* from C to C#

Answer 5

It is asking for a float pointer, (The machine address of a point in memory that contains an IEEE Floating point value.) C# does not allow managed use of pointers, so you will need to construct an IntPtr variable and pass that to the C++ function.

NOTE: Just because it is called IntPtr doesn't mean it is only a pointer to Integers. The Int is because all pointers are integers. It can be a pointer to anything.