C++ 如何实现可调整大小的堆栈数组？

Question

In one of my earlier lab exercises I implemented a simple stack program

#include<iostream>
#include<fstream>
#include<string>
using namespace std;

int count = 0; //stores the indexed number
string myStack[20]; //stores the data from file
string fileName; 
fstream readFile;
string storeFile;  //stores the data as a string

//function declarations/prototypes
void push(string aString);
string top();
string pop();
bool isEmpty();

int main(int argc, char *argv[])
{
  
  fileName = "file.txt";
  readFile.open(fileName); //attempts to read the file

      while(readFile >> storeFile){
          if(readFile.bad()) {
              cerr << "File failed to read " << endl;
              break; //loop terminates
                } else {
                    push(storeFile); //pushes file to stack
                } 
    }

readFile.close();

    while(isEmpty() !=true) {  //while file is not emptpy return the top stack.

       cout << top() << endl;
       pop();
    }
    return 0;
}


void push(string value) {
  
  myStack[count] = value;
  count++;
   
}

string pop() {
    if(count < 0) {
        return NULL;
    } else {
        count--; //decrement count for stack
        return myStack[count]; //return top value
    }
}

string top() {  //returns the current element at the top of the stack
return myStack[count];
}

bool isEmpty() { //checks whether or not the stack is empty
    if(count < 0) {
       return true;
    } 
    else return false;

    }

I am now required to revisit this program, however, this time modify it so that If you attempt to push data onto a full stack you should create a new array of twice the current size, copy the data from the old stack to the new stack and then delete the old stack without using STL or classes. We are allowed to use dynamic memory

So if the input, for example, looked something like this with an array size of 2

  push 1 
  push 1 
  push 1 
  push 1 
  push 1 
  pop 
  pop 
  push 1 

Then the output would look like this

Stack doubled from 2 to 4.
Stack doubled from 4 to 8.
Stack contains 4 entries.

How would I implement this? Thankyou

Push attempt

int dataCount = 0;     
const int SIZE = 5;
int capacity = 0;
int myStack[SIZE]; 

void push(int value)
{
   if(SIZE == capacity) {
   cout << "Doubling current size " << endl;
   capacity = capacity * 2;
   int* temp = new int[capacity];
   copy_n(myStack, SIZE, temp);
   std::swap(myStack, temp);
   delete[] temp;

   }
    myStack[dataCount] = value;
    dataCount++;
}

Answer 1

What you are asking for requires the stack array to be allocated in dynamic memory, eg:

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int count = 0; //stores the indexed number
int capacity = 0; //stores the allocated size
string *myStack = NULL; //stores the data from file

//function declarations/prototypes
void push(const string &aString);
string top();
void pop();
bool isEmpty();
void cleanup();

int main(int argc, char *argv[])
{
    string storeFile;  //stores the data as a string

    string fileName = "file.txt";
    ifstream readFile(fileName); //attempts to read the file

    while (readFile >> storeFile) {
        push(storeFile); //pushes file to stack
    }

    if (readFile.bad()) {
        cerr << "File failed to read " << endl;
    }

    readFile.close();

    while (!isEmpty()) { //while file is not empty return the top stack.
       cout << top() << endl;
       pop();
    }

    cleanup();

    return 0;
}

void push(const string &value) {
    if (count == capacity) {
        int newCapacity = (capacity == 0) ? 20 : (capacity * 2);
        string *newStack = new string[newCapacity];
        for(int i = 0; i < count; ++i) {
            newStack[i] = myStack[i];
        }
        delete[] myStack;
        myStack = newStack;
        capacity = newCapacity;
    }
    myStack[count] = value;
    ++count;  
}

string top() {
    if (count <= 0) {
        return string();
    }
    return myStack[count-1]; //return top value
}

void pop() {
    if (count > 0) {
        --count; //decrement count for stack
        myStack[count] = "";
    }
}

bool isEmpty() {
    return (count < 1);
}

void cleanup() {
    capacity = count = 0;
    delete[] myStack;
    myStack = NULL;
}

Answer 2

Create a class That has -Array start pointer -current size -the current position of the stack pointer

• a method that inflate the array , delete the previous one and copy the data of the previous -have a method that push on the stack and one that pops on top of the stack

You can event handle shrinking the stack when pop is less than length of the stack /2