C ++中类成员的动态分配

时间:2019-10-14 22:07:09

标签: c++ class dynamic-memory-allocation

我正在尝试使用C ++学习POO。我在小节中有关于内存分配的问题。我想创建一个堆栈类。我有用C ++编写的代码:

这是堆栈类:

class Stack {
    private:
        int *stackArray;
        int topLevel;

    public:
        // Constructor without par
        Stack() {
            stackArray = new int[NMAX];
            topLevel = -1; // stiva este NULL la inceput
        }

        Stack(int array_size) {
            stackArray = new int[array_size];
            topLevel = - 1;
        }

        ~Stack() {
            delete[] stackArray;
        }

        void push(int x) {
            int n_maxim = sizeof(stackArray) / sizeof(int);

            if (topLevel >= n_maxim - 1) {
                cout << "The stack is full !\n";
                return;
            }
            topLevel++;
            stackArray[topLevel] = x;
        }
};

这是主要功能:

int main() {
    int n;
    cout << "Introduceti numarul de elemente =";
    cin >> n;
    Stack *s = new Stack();
    s->push(6);
    s->push(10);
    return 0;
}

所以我的问题是内存分配无法正常工作,它无法使大小为NMAX(100)或大小为n的'v'数组从键盘读取。因此push函数仅适用于1个元素,因为我不知道为什么,该分配内存中的任何一个之后的sizeof(v)都是4。

2 个答案:

答案 0 :(得分:1)

您找不到像这样的堆栈大小:

int n_maxim = sizeof(stackArray) / sizeof(int);

因为这只是sizeof的指针除以sizeofint的指针,所以很可能是1

您想要类似的东西

class Stack {
private:
        int *stackArray;
        int topLevel;
        int n_maxim;

public:
        // Constructor without par
        Stack() {
            stackArray = new int[NMAX];
            topLevel = -1; // stiva este NULL la inceput
            n_maxim = NMAX;
        }

       Stack(int array_size) {
            stackArray = new int[array_size];
            topLevel = - 1;
            n_maxim = array_size;
        }
        ...

答案 1 :(得分:1)

您不能将sizeof()与动态分配的数组一起使用,它会返回int*指针本身的大小,而不是它指向的数组的大小。因此,您的班级将不得不跟踪数组的大小。

此外,您的课程未实现Rule of 3/5/0。您需要添加一个复制构造函数和一个复制赋值运算符,以便可以正确地复制数组的副本。

尝试一下:

#include <algorithm>

class Stack {
    private:
        int *stackArray;
        int arraySize;
        int topLevel;

    public:
        Stack(int array_size = NMAX) {
            stackArray = new int[array_size];
            arraySize = array_size;
            topLevel = -1;
        }

        Stack(const Stack &src) {
            stackArray = new int[src.arraySize];
            arraySize = src.arraySize;
            for (int i = 0; i < arraySize; ++i)
                stackArray[i] = src.stackArray[i];
            topLevel = src.topLevel;
        }

        ~Stack() {
            delete[] stackArray;
        }

        Stack& operator=(const Stack &rhs) {
            if (&rhs != this) {
                Stack temp(rhs);
                std::swap(stackArray, temp.stackArray);
                std::swap(arraySize, temp.arraySize);
                std::swap(topLevel, temp.topLevel);
            }
            return *this;
        }

        void push(int x) {
            if (topLevel >= (arraySize-1)) {
                cout << "The stack is full !\n";
                return;
            }
            topLevel++;
            stackArray[topLevel] = x;
        }
};