Конструктор не работает для класса, унаследованного от станда :: струнной

Question

при выполнении

#include <string> 

class MyString : public std::string 
{ 
public:  
    MyString() {} 
}; 

Но ниже использование:

MyString s = "Happy day"; 
MyString s("Happy Day"); 
MyString s = (MyString)"Happy day"; 

ни один из них работает.

Кажется, что что-то связано с объявлением/переопределением конструкторов/операторов, но может ли кто-нибудь помочь указать, где я могу найти эти ресурсы?

Спасибо.

Answer 1

Вам нужно определить некоторые конструкторов для различных типов, которые вы хотите, чтобы иметь возможность конвертировать в ваши строки. Эти конструкторы могут в основном просто передавать параметры до базового std::string.

Если вы не вручную создавать их, компилятор создает default- и копию-конструктор для вас:

MyString() : std::string() { } 
MyString(const MyString &other) : std::string(other) { } 

Чтобы разрешить строительство из строковых литералов, вам нужен конструктор, который принимает const char*:

MyString(const char* other) : std::string(other) { } 

конструктор, который принимает const std::string& также будет полезным для преобразования std::string с для вашего типа строки. Если вы хотите, чтобы избежать неявного преобразования нормальных строк, вы должны сделать это explicit:

explicit MyString(const std::string &other) : std::string(other) { } 

(под ред, потому что моя оригинальная версия была полна ошибок и я не могу удалить принятый ответ)

Answer 2

Вы определяете ctor MyString, который не принимает аргументов. Если переопределяет другие ctors, так что ctor не принимает строковый аргумент вообще.

Вы должны CTOR одного аргумента типа const char *, что-то вроде

MyString(const char * s): std::string(s){} 

(Не доверяйте синтаксис, посмотреть его, я не пишу C++ каждый день больше.)

Проверьте раздел в C++ FAQ Lite on ctors.

(К сожалению. Const символ *, а не строка. Об этом сообщил вам, что я не пишу C++ каждый день.)

Answer 3

Проблема заключается в том, что вам нужно перегрузить конструктор, который принимает константный символ * и вызовите базовый класс конструктор следующим образом:

class MyString : public std::string { 
    public:  
     MyString() {} 
     MyString(const char* c) : std::string(c) {} 
}; 

Все три ваших теста должны работать тогда.

Answer 4

std :: string не предназначен для унаследованных. У него нет виртуальных методов, поэтому вы не можете переопределить какие-либо его методы.

Вы должны изучить композицию. Или просто создавать служебные функции, которые работают на std :: strings

Answer 5

std::string не предназначен для наследования. Он не имеет любых виртуальных функций (даже не деструктор!), Поэтому вы не можете переопределить что-либо. Он также не имеет защищенного интерфейса, поэтому вы ничего не получаете от подкласса, который вы не могли бы получить, создав некоторые автономные служебные функции, которые принимают std::string.

Имейте в виду, что большинство реализаций STL предполагают, что вы используете std::string с семантикой семантики, а не с помощью семантики ссылок, и это делает случай более сложным добавление унаследованных полей или переопределяющих функций.

Если у вас действительно хотите что-то вроде std::string с дополнительными функциями, вы можете рассмотреть возможность использования композиции вместо наследования, но это тоже не очень удобно. Вам не нужно беспокоиться о том, что деструктор не получил правильное название, но вам нужно обернуть множество методов от std::string, которые вам нужны, что очень утомительно. Кроме того, ваши служебные функции будут работать только с MyString, когда большинство кода ожидают std::string, поэтому он не очень многоразовый.

Вам лучше сделать некоторые служебные функции, которые принимают std::string.Или, если std::string не предоставляет то, что вам нужно, вы должны пойти с некоторой другой реализацией строки, которая соответствует вашим потребностям. Вот некоторые возможности, которые приходят на ум:

• SGI STL extension, std::rope. Это в GNU C++, поэтому, возможно, вы можете положиться на него.
• Boost имеет довольно обширный string algorithm library, который позволяет использовать понятия для указания how your string is represented.
• Также см этого if you must "derive" от станда :: струнного

Answer 6

Дно что вы не должны этого делать. Деструктор на std::string не является виртуальным. Это означает, что если вы сделаете следующее:

std::vector<std::string*> s_vector; 
s_vector.push_back(new MyString("Hello")); 
s_vector.push_back(new std::string("World")); 

const std::vector<std::string*>::iterator s_vector_end = s_vector.end(); 
std::vector<std::string*>::iterator s = s_vector.begin(); 
for (; s != s_vector_end; ++s) 
{ 
    delete *s; // Error, MyString's destructor will 
       // not be called, but std::string's! 
} 

Единственный способ это может быть безопасным, если вы не добавлять пользователей в строку. Вы можете подумать, что вам сейчас не нужно, но кто-то, кто не знает об этой проблеме, может прийти позже (или вы, когда вы забыли этот совет, возможно) и добавите его, а затем, эй, престо, у вас есть трудно отследить утечку памяти.