c++ - 为什么 EXPECT_EQ 不能正确接受方法的结果作为参数？

Question

我正在学习数据结构，所以我通过模板制作了一个 Stack 类并使用 gtest 对其进行了测试。

虽然在使用 EXPECT_EQ 宏的 2 种方式中它显示不同的测试结果。

1. 这样，最后一行仅在我使用“RUN”配置而不是“DEBUG”配置的情况下触发异常。而且我发现它总是发生在最后一个 stack->pop 方法中，只要我完全清除堆栈并且堆栈中有多个元素。

TEST(Stack,isOK){
    auto stack = new Stack<int>();
    stack->Push(123);
    stack->Push(123);
    stack->Push(123);
    auto ret = stack->Pop();
    EXPECT_EQ(ret, 123);
    EXPECT_EQ(stack->Pop(), 123);
    EXPECT_EQ(stack->Pop(), 123);  // this line.
}

异常显示:

Running main() from D:\Homework\DataStructure\C++\Test\lib\googletest-master\googletest\src\gtest_main.cc
Running 1 test from 1 test suite.D:\Homework\DataStructure\C++\Test\tests\StackTest.cpp:15: Failure
Expected equality of these values:
  stack->Pop()
    Which is: -2147483136
  123

1 test from 1 test suite ran. (1 ms total)

1. 这样，所有的代码就顺利了。

TEST(Stack,isOK){
    auto stack = new Stack<int>();
    stack->Push(123);
    stack->Push(123);
    stack->Push(123);
    auto ret = stack->Pop();
    EXPECT_EQ(ret, 123);
    EXPECT_EQ(stack->Pop(), 123);
    ret = stack->Pop();
    EXPECT_EQ(ret, 123);  // ALL IS OK.
}

堆栈.h

//
// Created by anon on 2019/4/15.
//

#ifndef DATA_STRUCTURE_STACK_H
#define DATA_STRUCTURE_STACK_H

#include "Definition.h"

template<class T>
class Stack {
    const int stack_init_size = 1;
    const int stack_increment = 1;

protected:
    T *base;
    T *top;
    int stack_size;
public:
    Stack();
    ~Stack();
    Status          Clear();
    bool            empty();
    int             length();
    T               GetTop();
    Status          Push(T e);
    T               Pop();
};

template<class T>
Stack<T>::Stack() {
    stack_size = stack_init_size;
    base = (T *)malloc(sizeof(T) * stack_size);
    top = base;
}

template<class T>
Status Stack<T>::Clear() {
    return 0;
}

template<class T>
bool Stack<T>::empty() {
    return false;
}

template<class T>
int Stack<T>::length() {
    if (top == nullptr) {
        return 0;
    }
    else{
        auto val = (top - base);
        return val;
    }
}

template<class T>
Status Stack<T>::Push(T e) {
    if (length() == stack_size){
        auto old_base = base;

        base = (T *)realloc(base,(stack_size + stack_increment)* sizeof(T));
        if (!base) exit(ERROR);
        if (base != old_base){
            top = base + (stack_size * sizeof(T));
        }
        stack_size += stack_increment;
    }
    *top = e;
    top++;
    return OK;
}

template<class T>
T Stack<T>::Pop() {
    if (length() == 0)
        exit(ERROR);
    auto ret = *(top-1);
    top--;
    return ret;
}

template<class T>
Stack<T>::~Stack() {
    delete base;
}

template<class T>
T Stack<T>::GetTop() {
    if (length() == 0)
        exit(ERROR);
    return *(top-1);
}


#endif //DATA_STRUCTURE_STACK_H

Answer 1

为您的推送方法尝试以下操作:

template<class T>
Status Stack<T>::Push(T e) {
  if (length() == stack_size) {
    stack_size += stack_increment;
    base = (T *)realloc(base, stack_size * sizeof(T));
    if (!base) std::exit(ERROR);
    top = base + stack_size;
  }
  *top++ = e;
  return OK;
}

当您将整数 x 添加到类型 T* 的指针时，它不会按字面意义将指针的值增加 x .它将指针 x 向右移动“槽”，其中一个“槽”是一个 T 占用的空间。

因此，当您编写 top = base + stack_size; 时，top 的实际值为 base + (stack_size * sizeof(T)).

有关更多信息，请谷歌“指针算法”或参见 this reference