C++/C# Array shift equivilents

I'm trying to convert some code from C++ into C# and I'm not sure if these two statements would be equivalent.

C++ (the source):

float* df = new float[ length ]  // length is a previously initialized int
int coefIND = 0;
do
{
    float* const df2 = df + coefIND;开发者_高级运维
    // some element reassignments such as df2[1] = x[...] * y[...];
    coefIND += 4;
}
while(coefINF < length);
delete[] df;  // this occurs much later though

C# (translation?):

float[] df = new float[ length ]
int coefIND = 0;
do
{
     Array.Copy(df, 0, df, coefIND, length);
     // some element reassignments such as df[1] = x[...] * y[...];
     coefIND += 4;
}
while(coefIND < length)

Thanks for the help, Greg

---

You haven't shown the C# definition of df2, but probably the best solution is to just add coefIND to each index in the body of the code, rather than copying to a temporary array (and back again afterward.) Unlike C++, safe C# does not allow you to store a pointer to an element inside an array.

---

If you are desperate to do this way you could use linq.

df2 = df.Skip(coefIND).ToArray();

However I believe that in C++ you are assuming the size of a float is 4 bytes (hence the increment by 4.

A far better implementation of the loop would just be;

for (var coefIND=0;coefIND<df.length;coefIND++) {
  // some element reassignments such as df[coefIND] = x[...] * y[...];
}

Your code is mentioning df[1] in the comment, arrays are zero index so the way you had used this would have accessed memory past the end of your array.

---

The translation that you have provided is highly inefficient, as it requires copying of the contents of the array many times. The expression df[ x ] in C++ is equivalent to *(df + x), and you can apply that conversion to the code to obtain:

float[] df = new float[ length ]
int coefIND = 0;
do
{
     // some element reassignments such as:
     df[ coefIND + 1] = x[... ] * y[...];
     coefIND += 4;
}
while(coefIND < length);

Note that with all of the operations in the loop being unrolled, chances are that you will have a few extra additions (compared to the C++ code) but overall the performance should be almost the same.