Why is my std::string getting converted to std::basic_string<char>? - c++

Question

Error
stack.cc:53:28: error: no matching function for call to ‘Stack<std::basic_string<char> >::push(std::string)’
stack.cc:53:28: note: candidate is:
stack.cc:32:11: note: Stack<T>& Stack<T>::push(T&) [with T = std::basic_string<char>]
stack.cc
#include<iostream>
template <typename T>
class Stack {
private:
T* array_;
int length_;
T* last_;
void expandArray();
public:
Stack(int length = 8) {
array_ = new T[length];
length_ = length;
last_ = array_;
}
Stack<T>& push(T&);
T pop();
};
template<typename T>
void Stack<T>::expandArray() {
T* array_temp = new T[length_ << 1];
memcpy(array_temp, array_, length_);
std::swap(array_, array_temp);
delete[] array_temp;
length_ <<= 1;
}
template<typename T>
Stack<T>& Stack<T>::push(T& data) {
if (last_ == (array_ + length_ - 1)) {
expandArray();
}
last_[0] = data;
last_++;
return *this;
}
template<typename T>
T Stack<T>::pop() {
if(array_ != last_) {
T temp = last_[0];
last_--;
return temp;
}
return NULL;
}
int main() {
Stack<std::string> s;
s.push(std::string("a"))
.push(std::string("b"))
.push(std::string("c"))
.push(std::string("d"));
std::cout << s.pop() << std::endl;
std::cout << s.pop() << std::endl;
std::cout << s.pop() << std::endl;
std::cout << s.pop() << std::endl;
}
Wanted to understand why a conversion is happening from std::string to std::basic_string<char>?
Please feel free to comment on the code quality as well.

Answer 1

The actual problem is that you're attempting to pass a reference to an object created in the argument rather than stored in a variable. See that T& argument to Stack<T>::push? You cannot pass your temporary here because it's a non-const reference. Try as follows...
Stack<T>& push(const T&);
Use this signature for your implementation, too.
That being said, know that std::string is a mere typedef over std::basic_string<char>. This is because the functionality for strings can be extended to the other character types, too -- std::wstring for wchar_t, std::u16string for char16_t, and std::u32string for char32_t. ;-)
See §21.4 Class template basic_string [basic.string] of the C++11 specification.
// basic_string typedef names
typedef basic_string<char> string;
typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
typedef basic_string<wchar_t> wstring;
Note that you shouldn't rely on iostream to include string for you. You should also include cstring and specify the scope for your memcpy call.
By the way, you should really look into using an initializer list for Stack's constructor... see as follows.
Stack(int length = 8) : length_(length), array_(new T[length]), last_(array_) { }
Note that this functioning properly on array_ preceding last_ as a class member declaration ;-)
... AND a final note. Your pop is incorrect, since you're returning the element past the top. Instead, try something as follows...
template<typename T>
T Stack<T>::pop() {
if (array_ != last_) {
return *--last_;
}
/* other stuff here */
}
You need to decrement prior to dereferencing, since last_ points past the top. As a side note, you're also returning a copy of the std::string from pop, even though you stated you wanted to avoid as such.
Note you shouldn't be returning NULL since this isn't a pointer type. In fact, you'll just be creating an std::string via the constructor that takes a const char *... which is explicitly prohibited in the case of NULL. See §21.4.2¶8-9...
basic_string(const charT* s, const Allocator& a = Allocator());
Requires: s shall not be a null pointer.

Answer 2

std::string is a typedef for std::basic_string<char> it is not being converted to it, it is it. The reason is that the same std::basic_string template can be used with wchar_t to have unicode strings.

Answer 3

Because that is what std::string really is - it is just an alias for `std::basic_string':
typedef basic_string<char> string;
When the compiler is reporting the error message, it is displaying the typedef's real base type, not the alias name.