创建新数组时发生C ++错误：表达式必须具有指向对象类型的指针

Question

I am trying to create a new array with positive values only taken from a already created array, and when I am looping through the original array, the index has an error "Expression must have pointer to object type" I tried doing research on the error, and everyone's situation is different when getting this error so I am on my own with this. Here is my code:

int foo::createNewArray() const {
    int newarray[50];
    int oldarray = oldarray[values];
    int size = (sizeof(oldarray));

    for (int i = 0; i > size; i++){
        if (oldarray[i] > 0)
            newarray[i] = oldarray[i];
    }

The "i" above is what has the error. the oldarray[values] is declared in a seperate class file. Here is the small section of the code where it comes from.

        class foo{
        int oldarray[1];
        enum unit {values};

        public:
        int createNewArray() const;
};

Answer 1

Here you shadow oldarray array with a local int variable:

int oldarray = oldarray[values];

From that point on, until end of block, oldarray means an int, and then rest of the code does not make much sense with that.

Answer 2

The problem is because oldArray needs to be an int*, and not just an int. You are currently setting oldarray to the first value in the array, and not pointing it at the root of the array. So something like int* oldArray = newArray will let you iterate through oldArray using the index operator.

class Foo
{
    int* oldArray;
    int size;

public:
    int* CreateNewArray() const
    {
        int* newArray = new int[size];

        int current = 0;
        for( int index = 0; index < size; index++)
        {
            if(oldArray[index] > 0)
            {
                newArray[current] = oldArray[index];
                current++;
            }
        }

        return newArray;
    }
};

I apologize for haphazardly posting this without compiling. Although this solution may be closer to the metal than would be advised, it is still a valid solution to your problem, assuming oldArray and size are set before this method is called.

Answer 3

Here are some comments line by line of the problems with this code.

class foo{
    int oldarray[1]; //Do you really want an array of size 1?  Why not just an integer?
    enum unit {values};//An enumeration that only enumerates one thing?  Are you sure you don't really want const int VALUES = 0;  I feel like you don't really even want an enum

    public:
    int createNewArray() const; 
};

int foo::createNewArray() const {
    int newarray[50];  //Magic numbers are bad, what if sizeof(oldarray) > 50?
    int oldarray = oldarray[values];  //Re declaring oldarray as a single integer and assigning it oldarray[values] as its value.
    int size = (sizeof(oldarray));  //is this oldarray an integer or an array of integers???

    for (int i = 0; i > size; i++){  //don't you want i < size??? if size > 0, this loop will never get run.
        if (oldarray[i] > 0) //probably grabbing the correct oldarray(Compilers are smart), but not getting expected values because the array version of oldarray wasn't initialized properly.
            newarray[i] = oldarray[i];
    }

I believe what you're attempting to do is the following:

int* foo::createNewArray() const {
    const int SIZE = sizeof(oldarray);
    int *newArray = int[SIZE];
    for(int i = 0; i < SIZE; i++) {
        if(oldarray[i] > 0) {
            newArray[i] = oldarray[i];
        } else {
            newArray[i] = 0;//In most environments this is unnecessary, but it is safer and good style
        }
    }

    return newArray;
}

Note, that even this code will only work if oldarray is within the scope of this code(not great style, passing it in as an argument to createNewArray would be better, but okay) and was instantiated correctly so that sizeof(oldarray) is the size of the array and not the size of an integer, or perhaps an integer pointer, I forget.