Question

我要做的是创建一个堆栈类。堆栈的类型为char，但在创建char数组时出现编译时错误。语法看起来很好，但是当我编译它时，我得到下面的编译时错误：

stack.cpp: In constructor ‘stack::stack(int)’:
stack.cpp:17:14: error: cannot convert ‘char*’ to ‘int*’ in assignment
         _arr = new char[_capacity];
              ^
stack.cpp: In copy constructor ‘stack::stack(const stack&)’:
stack.cpp:24:14: error: cannot convert ‘char*’ to ‘int*’ in assignment
         _arr = new char[_capacity];

我发布了下面的标题和cpp文件：

    #include <iostream>
    #include <cstdlib>
    #include <cassert>
    using namespace std;

    #define INITCAP 8
    #define TYPE char

    class FullStackException{};
    class EmptyStackException{};

    class stack{
    public:
        // constructor with default capacity value
        stack(int=INITCAP);

        // copy constructor
        stack(const stack&);

        // assignment operator
        stack& operator=(const stack&);

        // destructor
        ~stack();

        // push an element;
        // if fixed sized stack, throw FullStackException when stack is full
        void push(const TYPE x);

        // remove and element; throw EmptyStackException when stack is empty
        void pop();

        // return a reference to the top element without popping; throw EmptyStackException when stack is empty
        TYPE& top();

        // return true if the stack is empty, false otherwise
        bool empty();

        // return the number of elements currently on the stack
        int  size();

        // return the current capacity of the stack
        int  capacity();

    private:
        TYPE * _arr;     // pointer to dynamic integer array
        int _tos;       // index to top of stack
        int _capacity;  // current capacity 
    }; 





    #include "stack.h"

    // constructor with default capacity value
    stack::stack( int n ) {
            _capacity = INITCAP;
            _arr = new char[_capacity];
            _tos = -1;
    }

    // copy constructor
    stack::stack( const stack& s ) {
            _capacity = s._capacity;
            _arr = new char[_capacity];

            for ( int i = 0; i < s._tos + 1; i++ ) {
                    _arr[i] = s._arr[i];
            }
            _tos = s._tos;
    }

    // assignment operator
    stack& stack::operator=( const stack& s ) {
            _capacity = s._capacity;

            for ( int i = 0; i < s._tos + 1; i++ ) {
                    _arr[i] = s._arr[i];
            }
            _tos = s._tos;

            return *this;
    }

    // destructor
    stack::~stack() {
            delete[] _arr;
    }

    // push an element;
    // if fixed sized stack, throw FullStackException when stack is full
    void stack::push(const TYPE x) {
            if ( _tos + 1 == _capacity ) {
                    _capacity *= 2;
                    int *temp = new int[_capacity];
                    for ( int i = 0; i < _capacity; i++ ) {
                            temp[i] = _arr[i];
                    }

                    delete[] temp;
            }
            _tos++;
            _arr[_tos] = x;
    }

    // remove and element; throw EmptyStackException when stack is empty
    void stack::pop() {
            if ( _tos == -1 ) {
                    throw EmptyStackException();
            }
            _tos--;
    }

    // return a reference to the top element without popping; throw EmptyStackException when stack is empty
    TYPE& stack::top() {
            if ( _tos == -1 ) {
                    throw EmptyStackException();
            }
            return _arr[_tos];
    }

    // return true if the stack is empty, false otherwise
    bool stack::empty() {
            return ( _tos == -1 );
    }

    // return the number of elements currently on the stack
    int stack::size() {
            return _tos + 1;
    }

    // return the current capacity of the stack
    int stack::capacity() {
            return _capacity;
    }

Answer 1

这看起来很奇怪

stack(int=INITCAP);

你似乎完全忽略了构造函数中的参数

stack::stack( int n ) {
        _capacity = INITCAP;
        _arr = new char[_capacity];
        _tos = -1;
}

更改为

stack(int n=INITCAP);

stack::stack( int n ) {
    _capacity = n;
    _arr = new TYPE[_capacity];
    _tos = -1;
}

甚至更好

stack::stack( int n )
: _tos(-1), _capacity(n) 
{
   _arr = new TYPE[_capacity];
}

请注意，您应该按照声明的顺序定义成员变量。

这可能会有所帮助，但你应该看一下模板，使用#define TYPE很难看

无法将char 转换为int

1 个答案:

无法将char *转换为int *

1 个答案:

无法将char 转换为int