Delphi vs C++ vs C# , ну и Java немножко, где-то ближе к старшему байту номеров страниц

Там нечто подобное, что по моей ссылке выше:

Куча текста

Цитата

21.3 String classes [string.classes]
1 The header <string> defines the basic_string class template for manipulating varying-length sequences of char-like objects and four typedefs, string, u16string, u32string, and wstring, that name the specializations basic_string<char>, basic_string<char16_t>, basic_string<char32_t>, and basic_string<wchar_-t>, respectively.
Header <string> synopsis
#include <initializer_list>
namespace std {
// 21.2, character traits:
template<class charT> struct char_traits;
template <> struct char_traits<char>;
template <> struct char_traits<char16_t>;
template <> struct char_traits<char32_t>;
template <> struct char_traits<wchar_t>;
// 21.4, basic_string:
template<class charT, class traits = char_traits<charT>,
class Allocator = allocator<charT> >
class basic_string;
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(const basic_string<charT,traits,Allocator>& lhs,
const basic_string<charT,traits,Allocator>& rhs);
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(basic_string<charT,traits,Allocator>&& lhs,
const basic_string<charT,traits,Allocator>& rhs);
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(const basic_string<charT,traits,Allocator>& lhs,
basic_string<charT,traits,Allocator>&& rhs);
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(basic_string<charT,traits,Allocator>&& lhs,
basic_string<charT,traits,Allocator>&& rhs);
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
§ 21.3 624

c ISO/IEC N3242=11-0012
operator+(const charT* lhs,
const basic_string<charT,traits,Allocator>& rhs);
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(const charT* lhs,
basic_string<charT,traits,Allocator>&& rhs);
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs);
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(charT lhs, basic_string<charT,traits,Allocator>&& rhs);
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(const basic_string<charT,traits,Allocator>& lhs,
const charT* rhs);
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(basic_string<charT,traits,Allocator>&& lhs,
const charT* rhs);
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(const basic_string<charT,traits,Allocator>& lhs, charT rhs);
template<class charT, class traits, class Allocator>
basic_string<charT,traits,Allocator>
operator+(basic_string<charT,traits,Allocator>&& lhs, charT rhs);

Операторы выделил жирным.

Сообщение отредактировано: OpenGL - 28.12.11, 19:51

Цитата OpenGL @ 28.12.11, 19:44

Там нечто подобное, что по моей ссылке выше:

А еще попрошу уточнить это новый стандарт?
Я сейчас просто нарыл предпоследний стандарт, как я понимаю, и вот что там пишут:

Скрытый текст

Цитата

namespace std {
template < class charT , class traits = char_traits <charT >,
class Allocator = allocator <charT > >
class basic_string {
public :
/ / types:
typedef traits traits_type ;
typedef typename traits :: char_type value_type ;
typedef Allocator allocator_type ;
typedef typename Allocator :: size_type size_type ;
typedef typename Allocator :: difference_type difference_type ;
typedef typename Allocator :: reference reference ;
typedef typename Allocator :: const_reference const_reference ;
typedef typename Allocator :: pointer pointer ;
typedef typename Allocator :: const_pointer const_pointer ;
typedef implementation-defined iterator ; / / See 23.1
typedef implementation-defined const_iterator ; / / See 23.1
typedef std :: reverse_iterator < iterator > reverse_iterator ;
typedef std :: reverse_iterator < const_iterator > const_reverse_iterator ;
static const size_type npos = -1;
/ / 21.3.1 construct/copy/destroy:
explicit basic_string ( const Allocator & a = Allocator ());
basic_string ( const basic_string & str );
basic_string ( const basic_string & str , size_type pos , size_type n = npos ,
const Allocator & a = Allocator ());
basic_string ( const charT * s ,
size_type n , const Allocator & a = Allocator ());
basic_string ( const charT * s , const Allocator & a = Allocator ());
basic_string ( size_type n , charT c , const Allocator & a = Allocator ());
template < class InputIterator >
basic_string ( InputIterator begin , InputIterator end ,
const Allocator & a = Allocator ());
~ basic_string ();
basic_string & operator =( const basic_string & str );
basic_string & operator =( const charT * s );
basic_string & operator =( charT c );
/ / 21.3.2 iterators:
iterator begin ();
const_iterator begin () const ;
iterator end ();
const_iterator end () const ;
reverse_iterator rbegin ();
const_reverse_iterator rbegin () const ;
reverse_iterator rend ();
const_reverse_iterator rend () const ;
/ / 21.3.3 capacity:
size_type size () const ;
size_type length () const ;
size_type max_size () const ;
void resize ( size_type n , charT c );
void resize ( size_type n );
size_type capacity () const ;
void reserve ( size_type res_arg = 0);
void clear ();
bool empty () const ;
/ / 21.3.4 element access:
const_reference operator []( size_type pos ) const ;
reference operator []( size_type pos );
const_reference at( size_type n) const ;
reference at( size_type n);
/ / 21.3.5 modifiers:
basic_string & operator +=( const basic_string & str );
basic_string & operator +=( const charT * s );
basic_string & operator +=( charT c );
basic_string & append ( const basic_string & str );
basic_string & append ( const basic_string & str , size_type pos ,
size_type n );
basic_string & append ( const charT * s , size_type n );
basic_string & append ( const charT * s );
basic_string & append ( size_type n , charT c );
template < class InputIterator >
basic_string & append ( InputIterator first , InputIterator last );
void push_back ( charT c );
basic_string & assign ( const basic_string & str );
basic_string & assign ( const basic_string & str , size_type pos ,
size_type n );
basic_string & assign ( const charT * s , size_type n );
basic_string & assign ( const charT * s );
basic_string & assign ( size_type n , charT c );
template < class InputIterator >
basic_string & assign ( InputIterator first , InputIterator last );
basic_string & insert ( size_type pos1 , const basic_string & str );
basic_string & insert ( size_type pos1 , const basic_string & str ,
size_type pos2 , size_type n );
basic_string & insert ( size_type pos , const charT * s , size_type n );
basic_string & insert ( size_type pos , const charT * s );
basic_string & insert ( size_type pos , size_type n , charT c );
iterator insert ( iterator p , charT c );
void insert ( iterator p , size_type n , charT c );
template < class InputIterator >
void insert ( iterator p , InputIterator first , InputIterator last );
basic_string & erase ( size_type pos = 0 , size_type n = npos );
iterator erase ( iterator position );
iterator erase ( iterator first , iterator last );
basic_string & replace ( size_type pos1 , size_type n1 ,
const basic_string & str );
Draft
basic_string & replace ( size_type pos1 , size_type n1 ,
const basic_string & str ,
size_type pos2 , size_type n2 );
basic_string & replace ( size_type pos , size_type n1 , const charT * s ,
size_type n2 );
basic_string & replace ( size_type pos , size_type n1 , const charT * s );
basic_string & replace ( size_type pos , size_type n1 , size_type n2 ,
charT c );
basic_string & replace ( iterator i1 , iterator i2 ,
const basic_string & str );
basic_string & replace ( iterator i1 , iterator i2 , const charT * s ,
size_type n );
basic_string & replace ( iterator i1 , iterator i2 , const charT * s );
basic_string & replace ( iterator i1 , iterator i2 ,
size_type n , charT c );
template < class InputIterator >
basic_string & replace ( iterator i1 , iterator i2 ,
InputIterator j1 , InputIterator j2 );
size_type copy ( charT * s , size_type n , size_type pos = 0) const ;
void swap ( basic_string & str );
/ / 21.3.6 string operations:
const charT * c_str () const ; / / explicit
const charT * data () const ;
allocator_type get_allocator () const ;
size_type find ( const basic_string & str , size_type pos = 0) const ;
size_type find ( const charT * s , size_type pos , size_type n ) const ;
size_type find ( const charT * s , size_type pos = 0) const ;
size_type find ( charT c , size_type pos = 0) const ;
size_type rfind ( const basic_string & str , size_type pos = npos ) const ;
size_type rfind ( const charT * s , size_type pos , size_type n ) const ;
size_type rfind ( const charT * s , size_type pos = npos ) const ;
size_type rfind ( charT c , size_type pos = npos ) const ;
size_type find_first_of ( const basic_string & str ,
size_type pos = 0) const ;
size_type find_first_of ( const charT * s ,
size_type pos , size_type n ) const ;
size_type find_first_of ( const charT * s , size_type pos = 0) const ;
size_type find_first_of ( charT c , size_type pos = 0) const ;
size_type find_last_of ( const basic_string & str ,
size_type pos = npos ) const ;
size_type find_last_of ( const charT * s ,
size_type pos , size_type n ) const ;
size_type find_last_of ( const charT * s , size_type pos = npos ) const ;
size_type find_last_of ( charT c , size_type pos = npos ) const ;
size_type find_first_not_of ( const basic_string & str ,
size_type pos = 0) const ;
size_type find_first_not_of ( const charT * s , size_type pos ,
size_type n ) const ;
size_type find_first_not_of ( const charT * s , size_type pos = 0) const ;
size_type find_first_not_of ( charT c , size_type pos = 0) const ;
size_type find_last_not_of ( const basic_string & str ,
size_type pos = npos ) const ;
size_type find_last_not_of ( const charT * s , size_type pos ,
size_type n ) const ;
size_type find_last_not_of ( const charT * s ,
size_type pos = npos ) const ;
size_type find_last_not_of ( charT c , size_type pos = npos ) const ;
basic_string substr ( size_type pos = 0 , size_type n = npos ) const ;
int compare ( const basic_string & str ) const ;
int compare ( size_type pos1 , size_type n1 ,
const basic_string & str ) const ;
int compare ( size_type pos1 , size_type n1 ,
const basic_string & str ,
size_type pos2 , size_type n2 ) const ;
int compare ( const charT * s) const ;
int compare ( size_type pos1 , size_type n1 ,
const charT * s ) const ;
int compare ( size_type pos1 , size_type n1 ,
const charT * s , size_type n2 ) const ;
};
}



///

21.3.5 basic_string modifiers [lib.string.modifiers]
21.3.5.1 basic_string::operator+= [lib.string:p+=]
basic_string <charT ,traits , Allocator >&
operator +=( const basic_string <charT ,traits , Allocator >& str );
1 Returns: append(str ).
basic_string <charT ,traits , Allocator >& operator +=( const charT * s );
2 Returns: *this += basic_string<charT,traits,Allocator>(s ).
3 Remarks: Uses traits::length().
basic_string <charT ,traits , Allocator >& operator +=( charT c );
4 Returns: *this += basic_string<charT,traits,Allocator>(1,c ).

Сообщение отредактировано: KILLER - 28.12.11, 20:08

Цитата KILLER @ 28.12.11, 19:40

возможно я ошибся в тут.

И сильно.

Цитата KILLER @ 28.12.11, 19:32

Но помню с этим оператором у меня были проблемы на какойто платформе.

При чём тут плюсы? Вопросы к создателям "платформы"...

Цитата MyNameIsIgor @ 28.12.11, 20:08

При чём тут плюсы? Вопросы к создателям "платформы"...

Да вопрос в принципе не в этом. Вопрос все тотже и остается. Может ты пояснишь, почему не сделать std::string через С-строки?

Цитата KILLER @ 28.12.11, 20:10

Может ты пояснишь, почему не сделать std::string через С-строки?

Что подразумевается под формулировкой "через жопу C-строки"?
Почему нужно делать именно так?

Цитата MyNameIsIgor @ 28.12.11, 20:08

И сильно.

Можешь раздел предыдущего стандартна назвать, я немогу его найти в Standard_ISO+IEC+14882-2003.pdf этом документе. Я понимаю что это не новый, новый еще толком не прижился просто...

Добавлено 28.12.11, 20:16

Цитата MyNameIsIgor @ 28.12.11, 20:11

Что подразумевается под формулировкой "через жопу C-строки"?
Почему нужно делать именно так?

По подобию std::vector, чтобы я имел дело не с каким то "через шею" сделанным классом строк, чтобы у меня был в распоряжении метод c_str, который я могу изменять, и передавать в С-функции, по подобиюю &vector[0] .

Цитата MyNameIsIgor @ 28.12.11, 20:11

Почему нужно делать именно так?

Потому что это как минимум правильно, а также обеспечивается обратная совместимость с С-строками.

Добавлено 28.12.11, 20:19

Цитата KILLER @ 28.12.11, 20:13

Можешь раздел предыдущего стандартна назвать, я немогу его найти в Standard_ISO+IEC+14882-2003.pdf этом документе. Я понимаю что это не новый, новый еще толком не прижился просто...

Похоже я нашел его, 21.3.7, ну нету у std::string operator+ своего... Он видимо глобально определен...

Цитата KILLER @ 28.12.11, 20:13

Можешь раздел предыдущего стандартна назвать, я немогу его найти в Standard_ISO+IEC+14882-2003.pdf этом документе. Я понимаю что это не новый, новый еще толком не прижился просто...

В Евангелии от Комитета 98-го года сие означено во 2-ом стихе 2-ой строфы 21-го параграфа.

Цитата KILLER @ 28.12.11, 20:13

По подобию std::vector

Дальше изречение читать не стал. Делать строки по подобию массива не считаю нужным.

Цитата KILLER @ 28.12.11, 20:13

Потому что это как минимум правильно

Не вижу в этом ничего правильного.

Цитата KILLER @ 28.12.11, 20:13

обеспечивается обратная совместимость с С-строками

Она и так есть...

Добавлено 28.12.11, 20:26

Цитата KILLER @ 28.12.11, 20:13

Он видимо глобально определен...

А я на cplusplus.com и дал сцылку, где было сказано, что он орпеделён вне basic_string. А что ему в нём делать то?

Цитата MyNameIsIgor @ 28.12.11, 20:25

Дальше изречение читать не стал. Делать строки по подобию массива не считаю нужным.

Обоснуй. В С - они есть массив, и ничего, люди живут, а в С++, смотрю уже пошли воротить носом. Обосновывай детально, я лично не понимаю этого.

Цитата MyNameIsIgor @ 28.12.11, 20:25

Не вижу в этом ничего правильного.

Аргументы.

Цитата MyNameIsIgor @ 28.12.11, 20:25

Она и так есть...

Она таки есть только для чтения, для записи ее нет.

Цитата MyNameIsIgor @ 28.12.11, 20:25

А я на cplusplus.com и дал сцылку, где было сказано, что он орпеделён вне basic_string. А что ему в нём делать то?

Хз, почему бы ему там и не быть.

Сообщение отредактировано: KILLER - 28.12.11, 20:30

Цитата KILLER @ 28.12.11, 20:30

Обоснуй.

Цитата KILLER @ 28.12.11, 20:30

Обосновывай детально, я лично не понимаю этого.

Цитата KILLER @ 28.12.11, 20:30

Аргументы.

Неа Мы будем делать наоборот. Вы мне будете обосновывать, а я сидеть и требовать аргументов. И да, "правильно", "для совместимости" - это не аргументы, а хотелки. А мне нужны детальные обоснования. А то не понимаю я таких желаний.

Цитата KILLER @ 28.12.11, 20:30

Она таки есть только для чтения, для записи ее нет.

Как это? Как люди работают с массивами символов в plain C? Прально, объявляют массивы на стеке или юзают malloc. Всё это доступно из плюсов => в данном моменте совместимость полная.

Цитата KILLER @ 28.12.11, 20:30

Хз, почему бы ему там и не быть.

А зачем ему там быть?

Цитата MyNameIsIgor @ 28.12.11, 20:35

Неа Мы будем делать наоборот. Вы мне будете обосновывать, а я сидеть и требовать аргументов. И да, "правильно", "для совместимости" - это не аргументы, а хотелки. А мне нужны детальные обоснования. А то не понимаю я таких желаний.

Я уже 15 страниц обосновываю как мне неприятно работать со строками через рот и в ухо, чтобы удалить только гланды. Вам мало моих аргументов? или у вас нет своих, и вы можете только что отвечать вопросом на вопросы, и своими задушевными фразами аля "не считаю нужным" ?
Основной аргумент в том, что мне приходится через временные переменные синхронизировать C-стороку с С++ строкой.

Цитата MyNameIsIgor @ 28.12.11, 20:35

Как это? Как люди работают с массивами символов в plain C? Прально, объявляют массивы на стеке или юзают malloc. Всё это доступно из плюсов => в данном моменте совместимость полная.

Да ёлкин ж свет... в плюсаъх есть std::string => и он нифига не совместим с С-строками, разве что в теории...

Цитата MyNameIsIgor @ 28.12.11, 20:35

А зачем ему там быть?

Ну незнаю. Лично я не любитель создавать глобальные функции/переменные в хидер файлах, уж очень неудобно их потом отлаживать. operator+ - могли бы без ущерба перенести в класс basic_string... Что в этом плохого? Я лично не вижу ничего плохого, плюс некоторые любят вызывать операторы через оператор .(точка) .

Добавлено 28.12.11, 20:47
MyNameIsIgor, знаешь, а один мой знакомый программист, еще будучи в универе, обрел дао глобальных переменных по примеру std. и потом усираясь доказывал всю их мощь, мол де, надо везде юзать глобальные переменые, погляди мол как круто работают std::cout, std::sin, а этож глобальные переменные, и вообще круче создать монолит из одного int main, чем плодить кучу классов со всякими виртуальными функциями и т.д. И я усираясь ему доказывал с пеной у рта, что это неправильно, так и не доказал. Но время всетаки показало как он был не прав, сейчас он кардинально изменил свою точку зрения...

Сообщение отредактировано: Qraizer - 29.12.11, 22:47

Цитата KILLER @ 28.12.11, 20:43

Я уже 15 страниц обосновываю как мне неприятно работать со строками через рот и в ухо

Не видел такого. Видел только нытьё на тему того, что сишные массивы символов нифига не строки. Ну, да, они массивы...

Цитата KILLER @ 28.12.11, 20:43

Да ёлкин ж свет... в плюсаъх есть std::string => и он нифига не совместим с С-строками, разве что в теории...

Да строки и не должны совмещаться с массивами.

Цитата KILLER @ 28.12.11, 20:43

operator+ - могли бы без ущерба перенести в класс basic_string... Что в этом плохого?

А что хорошего? operator+ делается через operator +=. Да и вообще было бы интересно посмотреть, как в классе строки объявить

template<class charT, class traits, class Allocator>
    basic_string<charT,traits,Allocator>
      operator+(const charT* lhs,
        const basic_string<charT,traits,Allocator>& rhs);

Цитата KILLER @ 28.12.11, 20:43

некоторые любят вызывать операторы через оператор .(точка)

Добавлено 28.12.11, 20:48

Цитата KILLER @ 28.12.11, 20:43

MyNameIsIgor, знаешь, [и далее по тексту]

Мораль сей басни какова?

Сообщение отредактировано: Qraizer - 29.12.11, 22:46

Цитата MyNameIsIgor @ 28.12.11, 20:47

Не видел такого. Видел только нытьё на тему того, что сишные массивы символов нифига не строки. Ну, да, они массивы..

Ну перечитай тогда.

Цитата MyNameIsIgor @ 28.12.11, 20:47

Да строки и не должны совмещаться с массивами.

С чего бы это? Вот ты пишешь тут строки, ты их видишь масивами или деревьями или может односвязными списками? Почему бы строкам не быть массивами, если они отродясь такими являются?

Цитата MyNameIsIgor @ 28.12.11, 20:47

А что хорошего? operator+ делается через operator +=. Да и вообще было бы интересно посмотреть, как в классе строки объявить

А что в этом плохого?

Цитата MyNameIsIgor @ 28.12.11, 20:47

Я не про себя ежели чего, я про то, что язык предоставляет такую возможность, хоть кривляйся, хоть не кривляйся.

Добавлено 28.12.11, 20:53

Цитата MyNameIsIgor @ 28.12.11, 20:47

Мораль сей басни какова?

Это было к глобальным переменным/функциям...

KILLER, не прикидывайся. Строки только и появились что в 1998 году в C++98. До этого их не было. Ни в C, ни в C++. Были массивы. Если тебе нравится называть их строками, боюсь, ты в меньшенстве. Глупо требовать от Win3xx совместимости по API с Win32. Обратная совместимость есть, и этого более чем достаточно, намного более чем. Массив символов уже и так есть. Либо используй строки как тип данных, либо не используй вообще. Тебя не смущает отсутствие в basic_(i)(o)stream параметров для управления ACLs?

Цитата OpenGL @ 28.12.11, 19:38

Кстати, вопрос к Qraizer. Почему Стандарт и Плюсы ты пишешь обычно с большой буквы?

Хм... ну Плюсы потому же, почему Дельфи, а Стандарт - потому что ссылаюсь на конкретный стандарт - международный Стандарт языка. Стандартов с маленькой буквы выше крышы, а если ещё вспомнить о стандартах предприятия, или стандартах кодирования, или промежуточных, неутверждённых, отклонённых ревизиях... В общем, Стандарт с большой буквы означает ссылку на законодательную базу.

Цитата KILLER @ 28.12.11, 20:43

в плюсаъх есть std::string => и он нифига не совместим с С-строками, разве что в теории...

Даже в теории они несовместимы. Даже желания такого ни у кого в Комитете (о! тоже с заглавной) не было. ПОтому что совместимый уже есть, и это вектор.

Цитата KILLER @ 28.12.11, 20:43

Лично я не любитель создавать глобальные функции/переменные в хидер файлах, уж очень неудобно их потом отлаживать. operator+ - могли бы без ущерба перенести в класс basic_string... Что в этом плохого? Я лично не вижу ничего плохого, ...

И напрасно не видишь. Этому оператору нечего делать в методах класса, ему вполне достаточно публичного интерфейса. Делая его методом, ты ухудшаешь инкасуляцию, ибо сильно связал с классом сущность, в такой связи не нуждающейся.
Другое дело, что одним оператором дело не ограничивается. Не помню, кто, но кто-то декомпозировал жирный std::basic_string<> до десятка методов, а остальное оставил за бортом класса и при этом абсолютно не в ущерб эффективности. Обычно в таких случаях публикацей интерфейса занимается namespace, а классы - инкапсулируют только жизненно необходимое быть завязанным на детали реализации плюс собственно аттрибуты класса в лице мемберов. В этом смысле не могу не согласиться, что std::basic_string<> спроектирован не лучшим образом, но с другой стороны вся STL лежит в едином namespace std, и делать исключение только лишь для строк было бы не менее странно. Вот boost спроектирован приятнее. Каждая сущность в своём boost::пространсте и в общем случае состоит из нескольких классов, типов, переменных, констант итп. Всё, что сильно связано - в классах, слабо связано - за их пределами, и всё в совопупности объеденено boost::пространством_имён.

Цитата Qraizer @ 28.12.11, 21:03

KILLER, не прикидывайся. Строки только и появились что в 1998 году в C++98.

Я в этом году балду пинал, и понятия не имел как комп включить если чо

Цитата Qraizer @ 28.12.11, 21:03

Были массивы. Если тебе нравится называть их строками, боюсь, ты в меньшенстве.

Почему бы завуалированно их не называть строками, пусть даже они будут массивами.

Цитата Qraizer @ 28.12.11, 21:03

Либо используй строки как тип данных, либо не используй вообще.

Ну как мне быть, если я их использую, но хочу чтобы код выглядел как работа со строками, С-строками, и при этом не прибегать к всяким векторам и временным массивам?

Цитата Qraizer @ 28.12.11, 21:03

Тебя не смущает отсутствие в basic_(i)(o)stream параметров для управления ACLs?

Смущает наверное(правда знать бы что такое ACLs)

Цитата Qraizer @ 28.12.11, 21:03

Даже в теории они несовместимы. Даже желания такого ни у кого в Комитете (о! тоже с заглавной) не было. ПОтому что совместимый уже есть, и это вектор.

Да, вектор как раз говорит сам за себя что он С-строка. А строки с помощью чего реализованы? Ведь все есть в std, и стеки и деревья и списки и очереди и хеш мапы разные, тебя не смущает что строки сделаны через то, чот уже есть, или они может по другому как то сделаны? В чем недостаток представления строк в виде массива символов?

Цитата Qraizer @ 28.12.11, 21:03

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

Конечно, только например я не любитель рыскать какие там глобалдьные переменные/операторы/функции которые предоставляет мне либа, написаная с использованием класса. У меня есть класс, я смотрю что он предоставляет, и работаю с тем что он мне предоставляет. остальное - от лукавого. Возможно я и ошибаюсь, но я так привык, мне так проще, а ипаца с выяснением какие там еще глобальные затычки понапиханы, для удобного использования этого класса - это не мое.

Цитата Qraizer @ 28.12.11, 21:03

Другое дело, что одним оператором дело не ограничивается. Не помню, кто, но кто-то декомпозировал жирный std::basic_string<> до десятка методов, а остальное оставил за бортом класса и при этом абсолютно не в ущерб эффективности. Обычно в таких случаях публикацей интерфейса занимается namespace, а классы - инкапсулируют только жизненно необходимое быть завязанным на детали реализации плюс собственно аттрибуты класса в лице мемберов. В этом смысле не могу не согласиться, что std::basic_string<> спроектирован не лучшим образом, но с другой стороны вся STL лежит в едином namespace std, и делать исключение только лишь для строк было бы не менее странно.

О да! Как приятно встретить рассвет, лицезрея пару тысяч функций/глобальных переменных/перегруженных операторов/тайпдефоф/и всего остального в пространстве имен std, через какойнить Ctrl+space

Сообщение отредактировано: KILLER - 28.12.11, 21:20

Цитата KILLER @ 28.12.11, 19:07

Я говорю о том, что хочу писать одностилевой код. Либо в стиле С++, с использованием стандартной библиотеки, либо в стиле С, используя stdlib.
...
При этом если я работаю со строками, и мне понадобилось поюзать сишную функцию, которая принимает С-строковый буфер

Взаимоисключающие параграфы.
Как ты собрался использовать Сишные либы и при этом одновременно с этим работать только в стиле С++?