Undefined reference to function

[Jack816]

Hello, on line 116 I'm getting an undefined reference to uninitialized_copy. Could someone explain why?

#ifndef VECTOR_HPP
#define VECTOR_HPP

//#include "test.hpp"

#include <vector>
#include <algorithm>
#include <memory>



template<class Out, class T>
void uninitialized_fill(Out, const T&);

template<class In, class Out>
Out uninitialized_copy(In, In, Out);



template<typename T>
class Vector
{
    using iterator = T*;
    using const_iterator = const T*;
    using size_type = size_t;
    using value_type = T;
private:
    iterator data;
    iterator limit;
    iterator avail;
public:
    Vector();
    explicit Vector(size_type n, const T &val = T())
    { create(n, val); }
    Vector(const Vector &v)
    {create(v.begin(), v.end());}
    Vector &operator=(const Vector& rhs);
    ~Vector()
    { uncreate(); }
    T &operator[](size_type i)
    { return data[i]; }
    const T& operator[](size_type i)const
    { return data[i]; }
    iterator begin()
    {return data;}
    const_iterator begin() const
    {return data;}
    iterator end()
    {return limit;}
    const_iterator end() const
    {return limit;}
    void push_back(const T&);

    size_type size() const
    {return avail - data;}
    std::allocator<T> alloc;
    void create()
    {data = avail = limit = 0;}
    void create(size_type, const T&);
    void create(const_iterator, const_iterator);
    void uncreate();
    void grow();
    void unchecked_append(const T& val)
    {alloc.construct(avail++, val);}
};
template <class T>
void Vector<T>::push_back(const T& val)
{
    if(avail == limit)
    grow();
    unchecked_append(val);
}

template <class T>
Vector<T>::Vector()
{
create();
}

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

template <class T>
void Vector<T>::create(const_iterator i, const_iterator j)
{
    data = alloc.allocate(j - i);
    limit = avail = unitialized_copy(i, j, data);
}

template <class T>
void Vector<T>::uncreate()
{
    if(data)
    {
        iterator it = avail;
        while(it != data)
        {
            alloc.destroy(--it);
        }
            alloc.deallocate(data, limit - data);
        }
    data = limit = avail = 0;
}

template <class T>
void Vector<T>::grow()
{

    size_type new_size = std::max(2 * (limit - data), ptrdiff_t(1));
    iterator new_data = alloc.allocate(new_size);
    iterator new_avail = uninitialized_copy(data, avail, new_data);

    uncreate();

    data = new_data;
    avail = new_avail;
    limit = data + new_size;
}
#endif 

[TheIdeasMan]

Where did you define this function? You have the declaration, but not the definition :+)

[Jack816]

I wouldn't have to define it because it is already defined in <memory>, correct? Your comment did make me realize that I didn't use std:: before it though. I don't understand why I got an error there even though I called it in my create function with no issues.

[TheIdeasMan]

I wouldn't have to define it because it is already defined in <memory>, correct?

Why do you think you need to declare functions that already exist in the STL?

Seen as you put a declaration on lines 15 and 16, the compiler thinks you want another function with that name. The linker error would appear regardless of whether you called std::unitialized_copy or not.

So get rid of the declaration and use std::unitialized_copy

Cheers :+)

[JLBorges]

a. Remove the declarations altogether and use qualified names
std::uninitialized_fill and std::uninitialized_copy everywhere in the header.

Note: the alternative of placing

using std::uninitialized_fill;
using std::uninitialized_copy ;

in a header file is not a good idea.



b. Correct spellings on lines 85, 92

// unitialized_fill(data, limit, val); // line 85
std::uninitialized_fill(data, limit, val);

// limit = avail = unitialized_copy(i, j, data); // line 92
limit = avail = std::uninitialized_copy(i, j, data);