error C2039: 'unintialized_fill" : is not a member of 'std' [closed] - c++

Question

This question is unlikely to help any future visitors; it is only relevant to a small geographic area, a specific moment in time, or an extraordinarily narrow situation that is not generally applicable to the worldwide audience of the internet. For help making this question more broadly applicable, visit the help center.
Closed 10 years ago.
I'm early in the stages of learning C++ and I'm working with classes. After recreating the functionality of a vector with my own class, the next step is to create my own version of a string using my new Vec class. I guess I'm too new to know how all these #includes interact but after searching many similar questions, it seems I'm just missing one somewhere. But it doesn't make sense to me because I assume I'm including the correct header where it's needed.
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
Before I even wrote the Str class, when I was just testing my Vec class, everything worked fine. I included Vec.h and could use my Vec in place of a vector.
Now with this new Str class that I made, I will include Str.h in my main source file and when I compile, it complains about std::uninitialized_copy not being a member of std. I know that it's defined in the memory header and can't figure out how to get it to see it, no matter where I put the include. I'm sure I'm just doing something wrong with the way classes interact with #includes but I'm new. If someone could help out I'd appreciate it.

Answer 1

std::unintialized_fill does not exist. You want std::uninitialized_fill with an i before the t.