I have written an implementation of Shared_ptr as part of working through the C++ Primer book. The header file does compile correctly, however I'm receiving several "No matching function" errors when I try to use it with a `Blob' class.
I've spent a few hours staring at the code and I think the problem is with the constructors, however I'm still a C++ beginner and haven't had any luck fixing it. I previously posted this on code review but was told it was 'off topic' and was instructed to post it here. The other posts on shared_ptr implementations there didn't help. Any feedback to set me in the right direction would be greatly appreciated.
Note: I haven't posted the Blob class as it is quite long, nor have I posted the test class. I'm happy to provide either if requested.
Example errors:
exercise_16.29.h: In instantiation of 'Blob< <template-parameter-1-1> >::Blob(std::initializer_list<_Tp>) [with T = int]':
exercise_16.30.cpp:9:33: required from here
exercise_16.29.h:58:103: error: no matching function for call to 'my_shared_ptr<std::vector<int, std::allocator<int> > >::my_shared_ptr(std::shared_ptr<std::vector<int, std::allocator<int> > >)'
template <typename T> Blob<T>::Blob(std::initializer_list<T> il): data(std::make_shared<std::vector<T>>(il)) { }
^
In file included from exercise_16.29.h:10:
exercise_16.28-1.h:50:1: note: candidate: 'my_shared_ptr< <template-parameter-1-1> >::my_shared_ptr(const my_shared_ptr< <template-parameter-1-1> >&, void (*)(T*)) [with T = std::vector<int, std::allocator<int> >]'
my_shared_ptr<T>::my_shared_ptr(const my_shared_ptr &rhs, void (*d)(T*)): p(rhs.p), del(d), count(rhs.count) {
^~~~~~~~~~~~~~~~
exercise_16.28-1.h:50:1: note: candidate expects 2 arguments, 1 provided
exercise_16.28-1.h:44:1: note: candidate: 'my_shared_ptr< <template-parameter-1-1> >::my_shared_ptr(const my_shared_ptr< <template-parameter-1-1> >&) [with T = std::vector<int, std::allocator<int> >]'
my_shared_ptr<T>::my_shared_ptr(const my_shared_ptr &rhs): p(rhs.p), del(nullptr), count(rhs.count) {
^~~~~~~~~~~~~~~~
exercise_16.28-1.h:44:1: note: no known conversion for argument 1 from 'std::shared_ptr<std::vector<int, std::allocator<int> > >' to 'const my_shared_ptr<std::vector<int, std::allocator<int> > >&'
exercise_16.28-1.h:20:12: note: candidate: 'my_shared_ptr< <template-parameter-1-1> >::my_shared_ptr(T*, void (*)(T*)) [with T = std::vector<int, std::allocator<int> >]'
explicit my_shared_ptr(T *pt, void (*d)(T*)): p(pt), count(new std::size_t(1)), del(d) { } //shared_ptr<T> p(q, d)
^~~~~~~~~~~~~
exercise_16.28-1.h:20:12: note: candidate expects 2 arguments, 1 provided
exercise_16.28-1.h:19:12: note: candidate: 'my_shared_ptr< <template-parameter-1-1> >::my_shared_ptr(T*) [with T = std::vector<int, std::allocator<int> >]'
explicit my_shared_ptr(T *pt): p(pt), count(new std::size_t(1)), del(nullptr) { } // shared_ptr<T> p(q)
^~~~~~~~~~~~~
exercise_16.28-1.h:19:12: note: no known conversion for argument 1 from 'std::shared_ptr<std::vector<int, std::allocator<int> > >' to 'std::vector<int, std::allocator<int> >*'
exercise_16.28-1.h:16:3: note: candidate: 'my_shared_ptr< <template-parameter-1-1> >::my_shared_ptr() [with T = std::vector<int, std::allocator<int> >]'
my_shared_ptr(): p(nullptr), del(nullptr), count(nullptr) { }
^~~~~~~~~~~~~
exercise_16.28-1.h:16:3: note: candidate expects 0 arguments, 1 provided
exercise_16.28-1.h: In instantiation of 'my_shared_ptr< <template-parameter-1-1> >::~my_shared_ptr() [with T = std::vector<int, std::allocator<int> >]':
Shared_ptr implementation:
#ifndef EXERCISE_16_28_1_H
#define EXERCISE_16_28_1_H
#include <cstddef>
#include <algorithm>
template <typename> class my_shared_ptr;
template <typename T> void swap(my_shared_ptr<T>&, my_shared_ptr<T>&);
template <typename T> my_shared_ptr<T> make_shared(T);
template <typename T> class my_shared_ptr {
friend void swap<T>(my_shared_ptr<T>&, my_shared_ptr<T>&);
friend my_shared_ptr make_shared<T>(T);
public:
my_shared_ptr(): p(nullptr), del(nullptr), count(nullptr) { }
//my_shared_ptr(T *pt): p(pt), count(new std::size_t(1)), del(nullptr) { }
//my_shared_ptr(T *pt, void (*d)(T*)): p(pt), count(new std::size_t(1)), del(d) { }
explicit my_shared_ptr(T *pt): p(pt), count(new std::size_t(1)), del(nullptr) { } // shared_ptr<T> p(q)
explicit my_shared_ptr(T *pt, void (*d)(T*)): p(pt), count(new std::size_t(1)), del(d) { } //shared_ptr<T> p(q, d)
my_shared_ptr(const my_shared_ptr&); // copy constructor
my_shared_ptr(const my_shared_ptr&, void (*d)(T*)); // copy constructor with deleter
my_shared_ptr& operator=(my_shared_ptr&); // copy assignment operator
~my_shared_ptr(); // destructor
T& operator*() const;
T* operator->() const;
T* get();
my_shared_ptr& swap(my_shared_ptr&);
bool unique() const;
std::size_t use_count() const;
my_shared_ptr& reset();
my_shared_ptr& reset(T*);
my_shared_ptr& reset(T*, void (*d)(T*));
private:
T* p;
void (*del)(T*);
std::size_t *count;
};
// copy constructor
template <typename T>
my_shared_ptr<T>::my_shared_ptr(const my_shared_ptr &rhs): p(rhs.p), del(nullptr), count(rhs.count) {
++*count;
}
// copy constructor with deleter
template <typename T>
my_shared_ptr<T>::my_shared_ptr(const my_shared_ptr &rhs, void (*d)(T*)): p(rhs.p), del(d), count(rhs.count) {
++*count;
}
// copy assignment operator
template <typename T>
my_shared_ptr<T>& my_shared_ptr<T>::operator=(my_shared_ptr &rhs) {
++*rhs.count;
--*count;
if(--*count == 0) {
del ? del(p) : delete p;
del ? del(count) : delete count;
}
p = rhs.p;
del = rhs.del;
return *this;
}
// destructor
template <typename T>
my_shared_ptr<T>::~my_shared_ptr() {
if(--*count == 0) {
del ? del(p) : delete p;
del ? del(count) : delete count;
}
del = nullptr;
}
// dereference operator
template <typename T>
T& my_shared_ptr<T>::operator*() const {
return *p;
}
// member access operator
template <typename T>
T* my_shared_ptr<T>::operator->() const {
return & this->operator*();
}
// get
template <typename T>
T* my_shared_ptr<T>::get() {
return p;
}
// member swap
template <typename T>
my_shared_ptr<T>& my_shared_ptr<T>::swap(my_shared_ptr &rhs) {
using std::swap;
swap(p, rhs.p);
swap(del, rhs.del);
return *this;
}
// unique
template <typename T>
bool my_shared_ptr<T>::unique() const {
if (*count == 1)
return true;
else
return false;
}
// use_count
template <typename T>
std::size_t my_shared_ptr<T>::use_count() const {
return count;
}
template <typename T> my_shared_ptr<T>& my_shared_ptr<T>::reset() {
if (--*count == 0) {
delete p;
delete count;
}
del = nullptr;
return *this;
}
template <typename T> my_shared_ptr<T>& my_shared_ptr<T>::reset(T *t) {
if (--*count == 0) {
delete p;
delete count;
}
p = t.p;
del = nullptr;
return *this;
}
template <typename T> my_shared_ptr<T>& my_shared_ptr<T>::reset(T *t, void (*d)(T*)) {
if (--*count == 0) {
delete p;
delete count;
}
p = t.p;
del = d;
return *this;
}
// make_shared
template <typename T>
my_shared_ptr<T> make_shared(T t) {
return my_shared_ptr<T>(new T(t));
}
// non-member swap
template <typename T> inline void swap(my_shared_ptr<T> &lhs, my_shared_ptr<T> &rhs) {
using std::swap;
swap(lhs.p, rhs.p);
swap(lhs.del, rhs.del);
}
#endif
Update:
Many thanks for the helpful replies so far. Using std::make_shared rather than make_shared was a debugging change I made, however I overlooked the fact that std::make_shared would return std::shared_ptr not my_shared_ptr. I have added the original compiler error message below where Blob uses my implementation of make_shared:
exercise_16.30.cpp:9:33: required from here
exercise_16.29.h:58:103: error: no matching function for call to 'my_shared_ptr<std::vector<int, std::allocator<int> > >::my_shared_ptr(std::shared_ptr<std::vector<int, std::allocator<int> > >)'
template <typename T> Blob<T>::Blob(std::initializer_list<T> il): data(make_shared<std::vector<T>>(il)) { }
^
In file included from exercise_16.29.h:10:
exercise_16.28-1.h:50:1: note: candidate: 'my_shared_ptr< <template-parameter-1-1> >::my_shared_ptr(const my_shared_ptr< <template-parameter-1-1> >&, void (*)(T*)) [with T = std::vector<int, std::allocator<int> >]'
my_shared_ptr<T>::my_shared_ptr(const my_shared_ptr &rhs, void (*d)(T*)): p(rhs.p), del(d), count(rhs.count) {
^~~~~~~~~~~~~~~~
exercise_16.28-1.h:50:1: note: candidate expects 2 arguments, 1 provided
exercise_16.28-1.h:44:1: note: candidate: 'my_shared_ptr< <template-parameter-1-1> >::my_shared_ptr(const my_shared_ptr< <template-parameter-1-1> >&) [with T = std::vector<int, std::allocator<int> >]'
my_shared_ptr<T>::my_shared_ptr(const my_shared_ptr &rhs): p(rhs.p), del(nullptr), count(rhs.count) {
^~~~~~~~~~~~~~~~
exercise_16.28-1.h:44:1: note: no known conversion for argument 1 from 'std::shared_ptr<std::vector<int, std::allocator<int> > >' to 'const my_shared_ptr<std::vector<int, std::allocator<int> > >&'
exercise_16.28-1.h:20:12: note: candidate: 'my_shared_ptr< <template-parameter-1-1> >::my_shared_ptr(T*, void (*)(T*)) [with T = std::vector<int, std::allocator<int> >]'
explicit my_shared_ptr(T *pt, void (*d)(T*)): p(pt), count(new std::size_t(1)), del(d) { } //shared_ptr<T> p(q, d)
^~~~~~~~~~~~~
exercise_16.28-1.h:20:12: note: candidate expects 2 arguments, 1 provided
exercise_16.28-1.h:19:12: note: candidate: 'my_shared_ptr< <template-parameter-1-1> >::my_shared_ptr(T*) [with T = std::vector<int, std::allocator<int> >]'
explicit my_shared_ptr(T *pt): p(pt), count(new std::size_t(1)), del(nullptr) { } // shared_ptr<T> p(q)
^~~~~~~~~~~~~
exercise_16.28-1.h:19:12: note: no known conversion for argument 1 from 'std::shared_ptr<std::vector<int, std::allocator<int> > >' to 'std::vector<int, std::allocator<int> >*'
exercise_16.28-1.h:16:3: note: candidate: 'my_shared_ptr< <template-parameter-1-1> >::my_shared_ptr() [with T = std::vector<int, std::allocator<int> >]'
my_shared_ptr(): p(nullptr), del(nullptr), count(nullptr) { }
^~~~~~~~~~~~~
exercise_16.28-1.h:16:3: note: candidate expects 0 arguments, 1 provided
exercise_16.28-1.h: In instantiation of 'my_shared_ptr< <template-parameter-1-1> >::~my_shared_ptr() [with T = std::vector<int, std::allocator<int> >]':```
As requested I have now included the Blob class and test code:
#ifndef BLOB_H
#define BLOB_H
#include <initializer_list>
#include <vector>
#include <string>
#include <memory>
#include <stdexcept>
#include <iostream>
#include "exercise_16.28-1.h"
template <typename> class BlobPtr;
template <typename> class Blob; // needed for parameters in operators below
template <typename T> bool operator==(const Blob<T>&, const Blob<T>&);
template <typename T> bool operator!=(const Blob<T>&, const Blob<T>&);
template <typename T> bool operator<(const Blob<T>&, const Blob<T>&);
template <typename T> bool operator>(const Blob<T>&, const Blob<T>&);
template <typename T> bool operator<=(const Blob<T>&, const Blob<T>&);
template <typename T> bool operator>=(const Blob<T>&, const Blob<T>&);
template <typename T> class Blob {
friend class BlobPtr<T>;
friend bool operator==<T>(const Blob<T>&, const Blob<T>&);
friend bool operator!=<T>(const Blob<T>&, const Blob<T>&);
friend bool operator< <T>(const Blob<T>&, const Blob<T>&);
friend bool operator><T>(const Blob<T>&, const Blob<T>&);
friend bool operator<=<T>(const Blob<T>&, const Blob<T>&);
friend bool operator>=<T>(const Blob<T>&, const Blob<T>&);
public:
typedef T value_type;
typedef typename std::vector<T>::size_type size_type;
// constructors
Blob();
Blob(std::initializer_list<T> il);
template <typename It> Blob(It b, It e);
// members
size_type size() const { return data->size(); };
bool empty() const { return data->empty(); }
// add and remove elements
void push_back(const T &t) { data->push_back(t); }
void push_back(T &&t) { data->push_back(std::move(t)); }
void pop_back();
// element access
T& front();
T& back();
const T& front() const;
const T& back() const;
T& operator[](size_type);
const T& operator[](size_type) const;
BlobPtr<T> begin() const; // return BlobPtr to the first element
BlobPtr<T> end() const ; // and one past the last element
private:
my_shared_ptr<std::vector<T>> data;
void check(size_type i, const std::string &msg) const;
};
template <typename T> Blob<T>::Blob(): data(make_shared<std::vector<T>>()) { }
template <typename T> Blob<T>::Blob(std::initializer_list<T> il): data(make_shared<std::vector<T>>(il)) { }
template <typename T>
template <typename It> Blob<T>::Blob(It b, It e): data(make_shared<std::vector<T>>(b, e)) {}
template <typename T> void Blob<T>::check(size_type i, const std::string &msg) const {
if (i >= data->size())
throw std::out_of_range(msg);
}
template <typename T> T& Blob<T>::front() {
// if the vector is empty, check will throw
check(0, "front on empty Blob");
return data->front();
}
template <typename T> const T& Blob<T>::front() const {
// if the vector is empty, check will throw
check(0, "front on empty Blob");
return data->front();
}
template <typename T> T& Blob<T>::back() {
check(0, "back on empty Blob");
return data->back();
}
template <typename T> const T& Blob<T>::back() const {
check(0, "back on empty Blob");
return data->back();
}
template <typename T> T& Blob<T>::operator[](size_type i) {
return data->at(i);
}
template <typename T> const T& Blob<T>::operator[](size_type i) const {
return data->at(i);
}
template <typename T> void Blob<T>::pop_back() {
check(0, "pop_back on empty Blob");
data->pop_back();
}
template <typename T> bool operator==(const Blob<T> &lhs, const Blob<T> &rhs) {
return *lhs.data == *rhs.data;
}
template <typename T> bool operator!=(const Blob<T> &lhs, const Blob<T> &rhs) {
return !(lhs == rhs);
}
template <typename T> bool operator<(const Blob<T> &lhs, const Blob<T> &rhs) {
return *lhs.data < *rhs.data;
}
template <typename T> bool operator>(const Blob<T> &lhs, const Blob<T> &rhs) {
return rhs < lhs;
}
template <typename T> bool operator<=(const Blob<T> &lhs, const Blob<T> &rhs) {
return !(lhs > rhs);
}
template <typename T> bool operator>=(const Blob<T> &lhs, const Blob<T> &rhs) {
return !(lhs < rhs);
}
template <typename T> bool operator==(const BlobPtr<T>&, const BlobPtr<T>&);
template <typename T> bool operator!=(const BlobPtr<T>&, const BlobPtr<T>&);
template <typename T> bool operator<(const BlobPtr<T>&, const BlobPtr<T>&);
template <typename T> bool operator>(const BlobPtr<T>&, const BlobPtr<T>&);
template <typename T> bool operator<=(const BlobPtr<T>&, const BlobPtr<T>&);
template <typename T> bool operator>=(const BlobPtr<T>&, const BlobPtr<T>&);
// BlobPtr throws an exception on attempts to access a nonexistent element
template <typename T> class BlobPtr {
friend bool operator==<T>(const BlobPtr<T>&, const BlobPtr<T>&);
friend bool operator!=<T>(const BlobPtr<T>&, const BlobPtr<T>&);
friend bool operator< <T>(const BlobPtr<T>&, const BlobPtr<T>&);
friend bool operator><T>(const BlobPtr<T>&, const BlobPtr<T>&);
friend bool operator<=<T>(const BlobPtr<T>&, const BlobPtr<T>&);
friend bool operator>=<T>(const BlobPtr<T>&, const BlobPtr<T>&);
public:
BlobPtr(): curr(0) { }
BlobPtr(const Blob<T> &a, size_t sz = 0): wptr(a.data), curr(sz) { }
T& operator*() const {
auto p = check(curr, "derefernce past end");
return (*p)[curr]; // (*p) is the vector to which this object points
}
BlobPtr& operator++(); // prefix operators
BlobPtr& operator--();
T& deref() const;
BlobPtr<T>& incr(); // prefix version
private:
// check returns a shared_ptr to the vector if the check succeeds
std::shared_ptr<std::vector<T>>
check(std::size_t, const std::string&) const;
// store a weak_ptr, which means the underlying vector might be destroyed
std::weak_ptr<std::vector<T>> wptr;
std::size_t curr; // current position within the vector
};
template <typename T> std::shared_ptr<std::vector<T>>
BlobPtr<T>::check(std::size_t i, const std::string &msg) const {
auto ret = wptr.lock(); // is the vector still around?
if (!ret)
throw std::runtime_error("unbound BlobPtr");
if (i >= ret->size())
throw std::out_of_range(msg);
return ret; // otherwise, return a shared_ptr to the vector
}
template <typename T> BlobPtr<T>& BlobPtr<T>::operator++() {
// if curr already points past the end of the container, can't increment it
check(curr, "increment exceeds bounds");
++curr;
return *this;
}
template <typename T> BlobPtr<T>& BlobPtr<T>::operator--() {
// if curr is zero, decrementing it will yield an invalid subscript
--curr; // move the current state back one element
check(curr, "decrement exceeds bounds");
return *this;
}
template <typename T> T& BlobPtr<T>::deref() const {
auto p = check(curr, "dereference past end");
return (*p)[curr]; // (*p) is the vector to which this object points
}
// prefix: return a reference to the incremented object
template <typename T> BlobPtr<T>& BlobPtr<T>::incr() {
// if curr already points past the end of the container, can't increment it
check(curr, "increment past end of BlobPtr");
++curr; // advance the current state
return *this;
}
template <typename T> bool operator==(const BlobPtr<T> &lhs, const BlobPtr<T> &rhs) {
return lhs.deref() == rhs.deref();
}
template <typename T> bool operator!=(const BlobPtr<T> &lhs, const BlobPtr<T> &rhs) {
return !(lhs == rhs);
}
template <typename T> bool operator<(const BlobPtr<T> &lhs, const BlobPtr<T> &rhs) {
return lhs.deref() < rhs.deref();
}
template <typename T> bool operator>(const BlobPtr<T> &lhs, const BlobPtr<T> &rhs) {
return rhs < lhs;
}
template <typename T> bool operator<=(const BlobPtr<T> &lhs, const BlobPtr<T> &rhs) {
return !(lhs > rhs);
}
template <typename T> bool operator>=(const BlobPtr<T> &lhs, const BlobPtr<T> &rhs) {
return !(lhs < rhs);
}
template <typename T> BlobPtr<T> Blob<T>::begin() const {
return BlobPtr<T>(*this);
}
template <typename T> BlobPtr<T> Blob<T>::end() const {
return BlobPtr<T>(*this, data->size());
}
#endif
#include "exercise_16.29.h"
#include <iostream>
#include <string>
#include <vector>
#include <list>
int main()
{
Blob<int> ib{21, 53, 84, 91, 23};
for (const auto &elem : ib)
std::cout << elem << ' ';
std::cout << '\n';
Blob<std::string> sb{"21", "53", "84", "91", "23"};
for (const auto &elem : sb)
std::cout << elem << ' ';
std::cout << '\n';
std::cout << '\n';
Blob<std::vector<std::string>> vb{ {"21", "5"}, {"53", "23", "42", "23"},
{"84", "59"}, {"91", "68"}, {"23", "72", "10" } };
for (const auto &vector : vb) {
for (const auto &elem : vector)
std::cout << elem << ' ';
std::cout << '\n';
}
int ia[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::vector<long> vi = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::list<const char*> w = {"now", "is", "the", "time"};
Blob<int> a1(std::begin(ia), std::end(ia));
Blob<int> s2(vi.cbegin(), vi.cend());
Blob<std::string> a3(w.cbegin(), w.cend());
return 0;
}
