Własny inteligenty wskaźnik

Dla treningu napisałem własny inteligentny wskaźnik, prosiłbym o feedback i odpowiedz na kilka pytań. Przykłady do pytań w komentarzach kodu.

1. Jaka jest różnica między nazwami metod unique_ptr i unique_ptr<T>?
2. W STL nie da się przypisać referencji do wskaźnika, jak to zrobić w moim kodzie?
3. W internecie widziałem, że ludzie przeciążając operator bool() dają przed nim explicit, dlaczego?
   Nie jestem w stanie sobie wyobrazić sytuacji, w której to coś daje.
4. Kilkukrotnie pisząc to miałem sytuacje, że kod się nie kompilował, po czym usuwałem jakąś metodę i przepisywałem ją w dokładnie taki sam sposób i program zaczynał działać. To jakiś błąd w MS VS, czy "programistyczny udar"?
5. Napisałem wszystko w jednym pliku cpp, bo podzielenie na dwa wywalało błędy, jak to poprawnie napisać?

template<typename T>
class unique_ptr
{
private:
	T* data;
public:
	unique_ptr& operator=(const unique_ptr&) = delete;
	unique_ptr(const unique_ptr&) = delete;
	unique_ptr()
		: data(nullptr) {};
	explicit unique_ptr(T* data) 
		: data(data) {};
	~unique_ptr()
	{
		delete data;
	}
	unique_ptr(unique_ptr&& ptr) noexcept	// 1. unique_ptr<T>(unique_ptr<T>&& ptr)
		: data(std::move(ptr.data))
	{
		ptr.data = nullptr;
	}
	unique_ptr& operator=(unique_ptr&& ptr) noexcept
	{
		if (this != &ptr)
		{
			data = std::move(ptr.data);
			ptr.data = nullptr;
		}
		return *this;
	}
	void reset()
	{
		delete data;
		data = nullptr;
	}
	T* release()
	{
		T* result = data;
		data = nullptr;
		return result;
	}
	T* get()
	{
		return data;
	}
	T& operator*() const
	{
		return *data;
	}
	T* operator->() const
	{
		return data;
	}
	const T* operator&() const	// 2. const int* p = &ptr, to nie powinno się kompilować
	{							//      std::cout << &ptr, a to powinno
		return data;
	}
	operator bool() // 3. explicit?
	{
		return data;
	}
};

@AnyKtokolwiek:
Mój unique_ptr - kompiluje się:

	unique_ptr<int> ptr = unique_ptr<int>(new int(5));
	const int* p = &ptr;
	delete p;

std::unique_ptr

	std::unique_ptr<int> ptr = std::unique_ptr<int>(new int(5));
	const int* p = &ptr; // error

error C2440: 'initializing': cannot convert from 'std::unique_ptr<int,std::default_delete<_Ty>> *' to 'const int *'

Jaka jest różnica między nazwami metod unique_ptr i unique_ptr<T>?
poczytaj o typach generycznych

leto napisał(a):

@AnyKtokolwiek:
Mój unique_ptr - kompiluje się:

Kopiuj

	unique_ptr<int> ptr = unique_ptr<int>(new int(5));
	const int* p = &ptr;
	delete p;

std::unique_ptr

Kopiuj

	std::unique_ptr<int> ptr = std::unique_ptr<int>(new int(5));
	const int* p = &ptr; // error

error C2440: 'initializing': cannot convert from 'std::unique_ptr<int,std::default_delete<_Ty>> *' to 'const int *'

W twoim, bardzo śmierdzi mieszanie typów (na mój nos PRZYNAJMNIEJ masz ostrzeżenia).
Szklana kula pracuje od 9:00

Fabryczny ma jak najbardziej prawidłowy i sensowny błąd.

Wywal operator& i będzie tak jak chcesz.

1 szablon vs konkretyzacja dla T
2 ???
3

unique_ptr<int> x = ...;
int val = x; // bez explicit może wywołać operator bool i skonwertować wynik do inta. Raczej nie o to chodziło.

4 PEBKAC
5 ???

@kq:
@AnyKtokolwiek:
Znalazłem winowajce punktu czwartego.
Standardowo mam ustawione ctrl + f5 jako compile and run, ale Microsoft Visual Studio z niewiadomych przyczyn czasami interpretuje to jako run.