将对象数组传递给成员函数

Question

Here is the class defination:

class Unit
{
    public:
     Unit();
     ~Unit();
     void set_unit(int a);
     void modify_flag(Unit&);
     void modify_array(Unit array[], int len);  // ?? The problem
     int show_unit();

    private:
     int ai;

};

And the implementation of the member functions:

void Unit::set_unit(int a)
{
     ai = a;
}

void Unit::modify_flag(Unit& u)
{
     u.set_unit(20);
}

void Unit::modify_array(Unit array[], int len)  // ?? The problem
{
     for (int i = 0; i < len; ++i)
     {
        modify_flag(array[i]);
        array[i].modify_array(array, len);
     }
}

int Unit::show_unit()
{
    return ai;
}

And finally the main code:

int main(int argc, char const *argv[])
{
    int len = 10;
    Unit* array = new Unit[len];

    for (int i = 0; i < len; ++i)
    {
        array[i].set_unit(0);
    }

    array[5].modify_array(array,len);  // ?? The problem


    for (int i = 0; i < len; ++i)
    {
        cout << array[i].show_unit() << endl;
    }

    delete [] array;

    return 0;
}

I passed an array of objects into the member function of the class as the parameter, but it aborted suddenly. I have checked my code many times to make sure the counter did not accumulate over the array length. Therefore, I think there must be something wrong with the object array as the parameter, but I could not figure it out. What happened with my code ??

Answer 1

1. Define the contructor & destructor of Unit Class.
2. To create array of objects : Unit *array[len].
3. Now you need to instantiate the objects by using new operator. Eg. array[1] = new Unit();
4. As you are using an object pointer you need to use arrow (->) operator to call functions instead of dot(.) operator.
5. Now when you call member functions from other member function of the same class you don't need to create and object to call that method.
6. One more point which was mentioned earlier by some other personnel modify_array calls itself and it is an infinite recursion.

Answer 2

You have uncontrolled recursion.

In modify_array the program will call

array[i].modify_array(array, len);

len times, each of which will call

array[i].modify_array(array, len);

len times, each of which will call

array[i].modify_array(array, len);

len times, each of which will call

array[i].modify_array(array, len);

len times...

You should be able to see where this is going.

Unfortunately, I'm not sure what your goal is so a can't suggest a proper solution, but You must have some exit condition to stop the chain of calls before you run out of automatic storage (most likely stack space).

For example you could

void Unit::modify_array(Unit array[], int len)  // ?? The problem
{
     for (int i = 0; i < len; ++i)
     {
        modify_flag(array[i]);
        array[i].modify_array(array, len - 1); // note the -1
     }
}

so that every iteration looks at less of the array. Eventually len will be 0 and i < 0 will result in no further calls. What good this does you, I can't say, but it stops the recursion.

Do you need the recursion at all? I don't know.

Answer 3

Thanks user4581301 for help! I finally found the mistake I made. The code I had written was to modify the whole array with a random starting index, so I tried to do it by resursive calls. I forgot to put the terminal condition, which must be the most important part, in my recursive function.

void Unit::modify_array(Unit array[], int len) 
{
 for (int i = 0; i < len; ++i)
  {
     if(need_to_modify(array[i]))
       array[i].modify_array(array, len);
   }
}

Something like this to jump out the loop. This was the my practice to get familiar with the recursive function. Thanks everyone.