将 float[] 作为 float* 参数传递的问题

Question

I will try to be as explicit as I can.

I have an exercise to solve, I've searched a lot on the web but could not find what my issue is.

Because this is an 'as is' Exercise I cannot modify float* to float[], I must use the values given and the function signature given. All I can work with is the contains of setWeight function.

Consider the following:

class Train
{
    protected:
    float* weight;

    public:
    setWeight(float* weight)
    {
        this->weight = weight;
    }
}

Then in main I call the following:

main()
{
    float weights[] = { 30.5f, 20.0f, 12.7f, 15.88f };
    train.setWeight(weights);
}

When I look in debug mode only the first value gets passed. Can someone help me out?

Answer 1

The program hasn't done anything wrong, but you are looking at it wrong.

In the debugger instead of reading train.weight and letting the debugger follow the pointer, try reading train.weight[0] , train.weight[1] , and train.weight[3]

Answer 2

If you cannot modify the signature of setWeight , you can provide the data as a dynamically allocated array.

main()
{
    Train train;
    float* weights = new float[4]{ 30.5f, 20.0f, 12.7f, 15.88f };
    train.setWeight(weights);

    //...
    delete[] weights;
}

Be aware you must at some point delete[] weights , and the moment you do, train will no longer contain valid values.

In the future, if you write a class similar to this, use RAII : Allocate with new in the constructor, and deallocate with delete in the destructor.

Answer 3

BACKGROUND : A pointer is a "special" type that stores a memory address. In this case, is a float value.

The thing is that an array is just syntactical sugar for handling pointers, since the name of an array is a pointer to the first element. If it's more general like a matrix, the compiler will run some fancy calculations to get it done. If you use a debugger, you will probably end up with that kind of situation since there is no way for the debugger to know that that pointer corresponds to a single value or the start of an array, a matrix, etc...

For example, this notation:

arr[1]

is translated as:

*(arr + 1)

PD: A cool trick you can retrieve from this, is that since the sum is commutative, you can transform the last expression in this:

*(arr + 1)
*(1 + arr)
1[arr]

And still works.

Answer 4

It's because you cannot this way, and it's really dangerous.

Hard array have a fixe space in memory, and is meant to be free when the variable go out of the scope.your pointer (float *) is just an adress to a memory space, you make it point to your hard memory space that will be free when you get out of the function, you will crash when you will try to use your variable.

    void setWeight(float* weight)
{
  float* Weight;
  Weight = weight;

  for (int i = 0; i < 4; ++i)
  {
    std::cout << *Weight << std::endl;
    ++Weight;
  }
}

int main()
{
  float weights[] = { 30.5f, 20.0f, 12.7f, 15.88f };
  setWeight(weights);
}

As you can see, i can see each hard float because i already know the size of the hard float array. When i do ++Weight i'm incrementing the pointer adress to go to the next value. (++Weight, is the same as Weight = Weight + 1)

BUT, it's not a copy, you have just a pointer to a hard space that will be free, and i need to know the size of the float[] passed in parameter

if we were in C i would tell you to malloc some space and copy one to the other, but, in c++ if you cna change the type of variable in your class, i will suggest a vector of float: std::vector<float> weight;