Question

我早期处于学习C ++的阶段，而且我正在使用课程。在使用我自己的类重新创建向量的功能之后，下一步是使用我的新Vec类创建自己的字符串版本。我想我太新了，不知道所有这些#includes如何相互作用，但在搜索了许多类似的问题后，似乎我只是在某个地方错过了一个。但这对我没有意义，因为我认为我在需要的地方包含了正确的标题。

Str.h

#ifndef GUARD_Str_h
#define GUARD_Str_h

#include <algorithm>
#include <iterator>

#include "Vec.h"

class Str {
public:
    typedef Vec<char>::size_type size_type;

    Str() { }

    Str(size_type n, const char& val): data(n, val) { }

    Str(const char* cp) {
        std::copy(cp, (cp + std::strlen(cp)), std::back_inserter(data));
    }
private:
    Vec<char> data;
};

#endif

Vec.h

#ifndef GUARD_Vec_h
#define GUARD_Vec_h

#include <cstring>
#include <memory>
#include <algorithm>

template <class T> class Vec {
public:
    typedef T* iterator;
    typedef const T* const_iterator;
    typedef size_t size_type;
    typedef T value_type;
    typedef std::ptrdiff_t difference_type;
    typedef T& reference;
    typedef const T& const_reference;

    Vec() { create(); } //constructor
    explicit Vec(size_type n, const T& val = T()) { create(n, val); } //constructor
    Vec(const Vec& v) { create(v.begin(), v.end()); } //copy constructor
    ~Vec() { uncreate(); } //deconstructor

    size_type size() const { return (avail - data); }

    void push_back(const T&);

    T& operator[](size_type i) { return data[i]; }
    const T& operator[](size_type i) const { return data[i]; }

    Vec& operator=(const Vec&);

    iterator begin() { return data; }
    const_iterator begin() const { return data; }
    iterator end() { return avail; }
    const_iterator end() const { return avail; }
private:
    iterator data;  //first element in the Vec
    iterator avail; //one past the last element in the Vec
    iterator limit; //one past the last availible space in the Vec

    std::allocator<T> alloc;

    void create();
    void create(size_type, const T&);
    void create(const_iterator, const_iterator);

    void uncreate();

    void grow();
    void unchecked_append(const T&);
};

template <class T> Vec<T>& Vec<T>::operator=(const Vec& v)
{
    if (v != this) {
        uncreate();

        create(v.begin(), v.end());
    }
    return *this;
}

template <class T> void Vec<T>::push_back(const T& val)
{
    if (avail == limit)
        grow();
    unchecked_append(val);
}

template <class T> void Vec<T>::create()
{
    data = avail = limit = 0;
}

template <class T> void Vec<T>::create(size_type n, const T& val)
{
    data = alloc.allocate(n);
    limit = avail = (data + n);
    std::unintialized_fill(data, avail, val);
}

template <class T> void Vec<T>::create(const_iterator beg, const_iterator end)
{
    data = alloc.allocate(end - beg);
    limit = avail = std::uninitialized_copy(beg, end, data);
}

template <class T> void Vec<T>::uncreate()
{
    if (data) {
        iterator iter = avail;
        while (iter != data)
            alloc.destroy(--iter);

        alloc.deallocate(data, (limit - data));
    }
    data = avail = limit = 0;
}

template <class T> void Vec<T>::grow()
{
    size_type new_size = std::max((2 * (limit - data)), difference_type(1));

    iterator new_data = alloc.allocate(new_size);
    iterator new_avail = std::uninitialized_copy(data, limit, new_data);

    uncreate();

    data = new_data;
    avail = new_avail;
    limit = (data + new_size);
}

template <class T> void Vec<T>::unchecked_append(const T& val)
{
    alloc.construct(avail++, val);
}

#endif

在我编写Str类之前，当我只是测试我的Vec类时，一切正常。我包括了Vec.h，可以使用我的Vec代替矢量。

现在使用我创建的这个新的Str类，我将在主源文件中包含Str.h，当我编译时，它抱怨std :: uninitialized_copy不是std的成员。我知道它是在内存标题中定义的，并且无论如何让它看到它都无法弄清楚，无论我把它放在哪里。我确定我只是在与#includes进行交互的方式上做错了，但我是新手。如果有人可以帮忙，我会很感激。

Answer 1

std::unintialized_fill不存在。您希望在 t 之前使用 i std::uninitialized_fill。

错误C2039：'unintialized_fill'：不是'std'的成员

1 个答案: