1

你好，我又遇到了另一个向量类问题。

这是我的 .CPP 文件

#include "myStringVector.hpp"

  void myStringVector::reserve(int n){
    if(!base){
      base = allocate<myString>(n);
      last = base;
      limit = base+n;
    }
    else{
      myString *p = allocate<myString>(n); //new base
      myString *q = p; //new last
      limit = p + n; //new limit
      myString *i = uninitialized_copy(base, last, q);
      destroy(i);
      deallocate(base);
      base = p; //update base
      last = q; //update last
    }
  }

  myStringVector::myStringVector(){
    this->reserve(0);
  }

  myStringVector::~myStringVector(){
    if(!base){
      deallocate(base);
      deallocate(last);
      deallocate(limit);
    }
    else{
      base = initialized_destroy(base, last);
      deallocate(base);
      deallocate(last);
      deallocate(limit);
    }
  }

  myStringVector::myStringVector(const std::initializer_list<myString>& list){
    std::cout << list.size() << "\n";
    this->reserve(list.size());
    last = uninitialized_copy(list.begin(), list.end(), last);
  }

  int myStringVector::size() const{
    return (last - base);
  }

  bool myStringVector::empty() const{
    return (this->size() == 0);
  }

  myString myStringVector::operator[](int index){
    return *(base+index);
  }

这是我的 .HPP 文件

#ifndef MYSTRINGVECTOR_HPP
  #define MYSTRINGVECTOR_HPP

  #include "myString.hpp"

  class myStringVector{
  private:
    myString *base = nullptr;
    myString *last = nullptr;
    myString *limit = nullptr;
  public:
    void reserve(int);
    myStringVector();
    ~myStringVector();
    myStringVector(const std::initializer_list<myString>&);
    int size() const;
    bool empty() const;
    myString operator[](int);

  };

  #endif //MYSTRINGVECTOR_HPP_INCLUDED

还使用这些功能...

template<typename T>
  inline T* uninitialized_copy(T const* first, T const* last, T* out)
  {
    while (first != last) {
      construct(out, *first);
      ++out;
      ++first;
    }
    return out;
  }

...

template<typename T>
  inline T* initialized_destroy(T* first, T* last)
  {
    while (first != last) {
      destroy(first);
      ++first;
    }
    return first;
  }

...

template<typename T, typename... Args>
  inline T* construct(T* p, Args&&... args)
  {
    return new (p) T(std::forward<Args>(args)...);
  }

...

template<typename T>
  inline T* allocate(int n)
  {
    return reinterpret_cast<T*>(::operator new(n * sizeof(T)));
  }

和...

template<typename T>
  inline void deallocate(T* p)
  {
    ::operator delete(p);
  }

我的主要做这个...

{
myStringVector v;
assert(v.empty());
std::cout << "Passed default ctor" << std::endl;
myStringVector v1 {"a", "b", "c"};
myStringVector v2 {"d", "e", "f"};
std::cout << v1.size() << " " << v2.size() << "\n";
std::cout << v1[0] << v1[1] << v1[2];
}

myString 只是一个自定义字符串类。它就像一个普通的字符串类。

当我运行 main 时，我希望 v1 能够保存 a、b 和 c。和 v2 来保存 d、e 和 f。但这就是我得到的...

ap÷bp÷cp÷

所以看起来它在每个字符之后用额外的垃圾初始化每个索引。我试过不使用reserve() 和uninitialized_copy 直接初始化，它工作正常。但是，我的教授要求我使用这些令人困惑的内存管理功能。我假设我错误地使用了这些函数，但是当编译器没有给我任何错误时，很难知道要修复什么。

如果有人可以帮助我了解我做错了什么以及为什么我会看到垃圾值，我将非常感激。

谢谢！

4

1 回答 1

1

你说

myString 只是一个自定义字符串类

但是你是如何实现的呢？

我的直接印象是您的自定义字符串类正在复制字符并且未能在它们的末尾放置终止的空值。

另一个关键点是您正在使用cout，因此您需要知道您的自定义字符串是如何编写的。例如：如果您有一个operator const char*then 将被拾取，并且流输出将期待一个真正的C 字符串，其终止为 null。

查看oofString 输出

ostream& 
operator<<(ostream& os, const oofString& str)
{
    os << str.chars();
    return os;
}

其中chars()定义为：

inline const char*
oofString::chars() const
{
    if (mBody)
        return mBody;
    else
        return "";
}

我在这个问题中看到的任何内容都没有myStringVector表明问题的根源。

于 2020-12-01T04:25:13.647 回答