Выходной, рассуждения от нечего делать )

[Алексей++]

lapulya, так про то и речь, что я сначала без транзакции пробовал

Ну а твои издевательства над строкой и потом искреннее удивление почему у меня во втором объекте строки что-то поменялось и типа вывод "Ага!!! не работает!!!" ну или что-то в этом роде (без обид). Сродни тому что я когда то писал тут на форуме про возвращение приведенного объекта с примерно следующим примером

не было издевательств. Я просто напросто использовал CString как временный буфер, вот и всё. Просто сначала не учёл особенность работы класса. Что у тебя вызывает недоумение - я так до сих пор и не понял

int i = 10;

class MyWindow : public CWnd
{
    CWnd * getWnd();
};

CWnd * MyWindow::getWnd()
{
   return (CWnd *)i;
}

компилится, но не работает

а что будет там работать ? Ты делаешь  ((CWnd*)10) - выражение, возвращаемое значение которого нигде не использовано , ты ничего и не увидишь

[lapulya]

Когда я про издевательства писал я имел ввиду эту строчку

Код:

	strtok((char*)(const char*)txt2,".\r\n");

в этом коде

Код:

	//используем txt2 как временный локальный буфер,
	//чтобы не менять txt1 (хотя глюк всё равно поменяет txt1)

	CString txt2;
	txt2=txt1;
	strtok((char*)(const char*)txt2,".\r\n");

а что касается моего примера, то я имел ввиду что ты делаешь ммм "незаконные операции" (об этом кстати тебе сразу и Finch сказал), там еще у меня ошибочка, вот так надо ессесно

Код:

   return (CWnd *)&i;

вот я нашел о чем говорил https://forum.shelek.ru/index.php/topic,3792.msg72511#msg72511

[Алексей++]

   return (CWnd *)&i;
 - это логическая ошибка , так всё равно низя делать

а я незаконного ничего не делал , просто не учёл особенность класса.

[lapulya]

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

как это ничего незаконного не делал?... а кто константный поинтер на неконстантный поменял? Ты ж реализацию CString не знаешь, а в предоставленный тебе константный буфер произвел запись!!! Да ты потенциально мог винт отформатировать, а ты говоришь ничего незаконного не делал.

[Алексей++]

lapulya, я достаточно знаю реализацию CString , это всего лишь указатель на строку , заканчивающуюся нулём. Единственное, что не знал - что копируется указатель, а не сама строка.
Отформатировать ничего я не мог ))) Я даже ДЛИНУ строки не менял , только значения байтов в строке

[lapulya]

Если ты не знал что копируется указатель, значит не достаточно знал реализацию, то что ты длину не менял это уже хорошо, но потенциально все равно плохо.

Понимаешь если я тебе 100 рублей посмотреть (посмотреть - ключевое слово) дам, а ты не меня размеров и формы бумаги, закрасишь гос номер или что-то вроде этого, использовать 100 рублей по прямому назначению я уже не смогу - это грубый, но явный пример, а вот если ты например скомкаешь, то вроде все хорошо, ты их вроде вообще не менял (типа все законно и честно), но условно говоря протислуть эту панкноту в щель 0,1 мм я уже не смогу (а мне это необходимо для какой-то там цели о которой ты и не догадывался) - это тоже грубый, но для тебя не явный пример (ты ж с ней вообще ничего нехорошего не делал, а я ее использовать уже не могу)

[Алексей++]

lapulya, а ты особо знаешь про устройство своего любимого std::string ?

а пример не принимается, потому что у 100 рублей нету области видимости

[lapulya]

я по std::string знаю достаточно (в том числе и в дебрях реализации копался достаточно, а это не тоже самое что в реализвции MFC ))) ), но естественно не все (не  я же писал )))) ).

НО!!! Смысл в том, что поскольку я знаю реализацию внешних по отношению к моему коду библиотек и модулей (в том числе и stl) не как свои 5 пальцев я никогда не пишу такого

char * buff = (char * )(const char *)string.c_str();
myChangeString(buff);

ну и соответственно не имею проблем. Более того, тот же stl я изучал не только по исходникам и примерам, а еще как минимум по 5 - 7 книгам и тучей статьям, и там как раз указано, и на различия в реализациях stl разных производителей, и часто встречаемые проблемы, а также что гарантирует стандарт в отношении библиотеки, а что нет.

Теперь про 100 рублей... Как же это нет области видимости... конечно же есть и инкапсуляция на лицо!!! Иначе и пример бы был некорректный.
Дело то вот в чем, если бы ты знал что с банкнотой необходимо сделать мне (ну кроме прямого ее назначения, типа купить на нее что-то), то ты бы ее мять не стал, поскольку ты бы знал что мне ее потом в щель совать, а вот поскольку это была инкапсуляция и в твоей области видимости была просто банкнота, то с твоей стороны смять ее не означалобы ровным счетом ничего страшного, поскольку ты ее видел исключительно как "деньгу", которая от "смятости" ну ничего не теряет в плане покупательской способности.

[Алексей++]

lapulya, когда я пишу

Код:

(char * )(const char *)string.c_str();

я сознательно делаю нарушение только в (char *) , как бы тебе это странно не казалось
А поскольку я сознательно делаю неправильно, но удобно, я делаю следующие ограничения свободы для экземпляра класса:

1) сильно ограничиваю видимость (открыл фигурную скобку, создал экземпляр, сделал, что надо, убил экземпляр второй скобкой) , гарантируя, что нигде дальше не использую этот "исковерканный" экземпляр
2) я не нарушаю связь "знание экземпляра о размере буфера" и , собственно, "размер буфера" - я лишь меняю значения байтов буфера, не трогая последний ноль
3) чтобы буфер скопировался, теперь применяю += , если требуется


а 100 рублей - если я в них, извиняюсь, высморкался, кто то будет влипать в эти сопли Так что плохое сравнение

[lapulya]

))) Леха у меня ща рука отвалится писать, есть у тебя скайп давай я тебе позвоню и объясню ))))

Я уже сказал, что это хорошо, что ты не меняешь размер, последний ноль и т.д. и т.п. (скобки, область видимости...)  НО это все равно ОЧЕНЬ плохо. Понимаешь буфер константный, программист когда его тебе давал расчитывал что этот буфер доступен тебе только для чтения, а ты его меняешь!!! (учитывая все твои предосторошности, НО ты его меняешь!!! а расчет был на то что он константный!!!)

Могу рассказать сказку, которая скореее всего былью не станет, но сама суть не меняется, а сказка такая, допустим реализация класса строки такая, перед тем как тебе отдать сонстантную строку происходит копирование ее же в какой-то буфер до которого тебе доступа таки нет (приватная переменная без достепа извне)..., далее при любом ШТАТНОМ (тобишь или приватными функциями или публичными set или change функциями) изменении буфера, который был тебе отдан как константный, происходит сверка этого буфера с приватным и если есть отличия программер писавший эту библиотеку, понимает, что его библиотеку юзают не хорошие люби (они таки меняют содержимое его ЛЮБИМОГО КОНСТАНТНОГО буфера) и мстя всем идет вызов функции форматирующей винт.

Заметь, такое ну вот запросто может быть с точни зрения концепции, а не конкретного примера, поэтому изменение "чужего" константного объекта в общем случае приводит к непредсказуемым последствиям (я собственно только об этом и писал)

Ну с банкнотой сожет и не удачный пример (хотя мне так не кажется), но очень наглядный (один в один с содержанием сказки). Вот опять же... я после того как дат тебе посмотреть банкноту хотел ну там провести ей по ТВОЕМУ пиджаку, типа послушать как хрустит (это мои инкапсулированный намерения, тебе о них неизвестно, ровно так же как и сверка с внутренним буфером) а ты в них сморкаться... и в итоге!!! ТВОЙ пиджак в соплях (это был формат винта ))) )

[Алексей++]

lapulya, константное ОЗУ есть ПЗУ , так что в ОЗУ понятие - константа - относительно Я также частенько делаю нарушения такие, как объявление константными некоторых мемберов класса, но в конструкторе я их всё же заполняю, но нигде более.

Теперь, CString задуман, дабы инкапсулировать строку, заканчивающуюся нулём, даже оператор (const char*) просто возвращает указатель на начало буфера - и этот указатель можно подсунуть тем же апишным функциям, которые старше , чем CString , соответственно, я с чистой совестью могу делать с буфером то же самое.

Паранойя с форматированием винта - налицо   Оффтоп: У нас в тренажёрку ходит парень, который уверен, что за нами всеми НАБЛЮДАЮТ. Везде камеры и прослушка, даше в штанге, которую он любит поднимать )

Код:

и в итоге!!! ТВОЙ пиджак в соплях 

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

[Алексей++]

кстати, самое интересное забыл сказать - мне всего один раз так пришлось поступить с буфером CString - когда пользовался strtok . Он, собака, меняет строку

[lapulya]

))))))))))))))))))))))))))))))))))))))))))))))
со всеми высказываниями не согласен.

константное ОЗУ есть ПЗУ , так что в ОЗУ понятие - константа - относительно

Константное ОЗУ и ПЗУ совершенно разные вещи. Ни какой относительности в понятии конста в ОЗУ нет.

это вообще законно

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

есть такое ключевое слово в С++ mutable, да и инициализация в конструкторе вот в таком виде

Код:

class A
{
const int i;
public:
A();
}

A::A() : i(10)
{}

не противоречит стандарту.

Если класс не твой, править константный буфер очень плохо (объяснил как мог).

Про CString, он задуман для простой работы со строкой, а не для

Код:

дабы инкапсулировать строку, заканчивающуюся нулём 

оператор (const char*) не

Код:

просто возвращает указатель на начало буфера 

а возвращает указатель на константный!!! буфер, который ты в праве только читать, этот буфер можно дать только тем АПИ функциям которые на входе хотят сонстантнй буфер (если АПИ функция хочет просто /типа неконстантный/ буфер, компилятор скажет что ты не прав). Совершенно очевидно, что работа cString с этим буфером не такая уж и простая, поскольку при присвоении одного объекта CString другому у них общий буфер, а это значит, что там еще тьма кода которая как-то обрабатывает этот буфер и смотрит на его содержание. Еще раз говорю, если класс не твой, править константный буфер очень плохо.

С банкнотой все нормально, сама банкнота никакой копией не является (как в примере буфер),  копией будет только ммм "твои пальцы" (т.е. поинтер на буфер, благодаря которому ты знаешь где искать и как обратиться к буферу) которыми ты берешь купюру.

Ну а про формат винта, это ммм как бы сказать то, худшее развитие событий, упоминание о котором должно отрезвлять собеседника.

PS
Где есть один раз, там и до второго не далеко.

[Алексей++]

Константное ОЗУ и ПЗУ совершенно разные вещи.

конечно разные, потому что ОЗУ и ПЗУ - это и так разные типы памяти

Ни какой относительности в понятии конста в ОЗУ нет.

хорошо, относительности нет, согласен. В ОЗУ - ВСЁ НЕ КОНСТАНТНОЕ.

mutable

незнакомое словечко, нашёл в мсдн (спасибо за пополнение тезауруса , может пригодится когда нибудь):
This keyword can only be applied to non-static and non-const data members of a class. If a data member is declared mutable, then it is legal to assign a value to this data member from a const member function.

и вижу, что мне это не подходит, так как переменную потом можно всё же поменять, не приводя к неконстанте. Мне такое не требуется, для этого можно сделать приватную переменную. Мне же требовалось (речь не про CString, кстати) заполнить переменную только в конструкторе и больше НИГДЕ не менять , то есть компилятор бы мне эти места сам указал

class A
{
const int i;
public:
A();
}

A::A() : i(10)
{}не противоречит стандарту.

а мне нужно было

Код:

class A
{
const int i;
public:
A(int val_in);
}

A::A(int val_in) : i(0)
{
  *((int*)i)=val_in;
}

Про CString, он задуман для простой работы со строкой, а не для

- покажи, где написано, что он задуман не для упрощения работы с нуль-терминаторной строкой ? И что оператор возвращает не указатель на начало буфера ?

Код:

//"AFXINL.H"
_AFX_INLINE CString::operator LPCTSTR() const
	{ return m_pchData; }

с банкнотой косяк - с ксерокопией я могу делать что хочу

Где есть один раз, там и до второго не далеко.

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

[lapulya]

Нет, в ОЗУ есть константные область и есть не константные. Ну например есть у тебя константная строка (типа допустим приветсвие в чате) "Всем, всем доброго утра". И вот эта строка прогрузжается в ОЗУ при запуске. Эта строка появляется каждый раз когда пользователь заходит в чат. Ты эту константу меняешь (раз у тебя в ОЗУ все не константное), на "Умри падла!!!". Итог очевиден (как минимум не то что хотелось... наверное ))) )

вот тебе лекарство для твоей болезни

Код:

class A
{
const int i;
public:
A(int val_in);
}

A::A(int val_in) : i(val_in)
{}

Вот для чего нужна CString (типа показываю)

The topics in this section describe programming using CString, which is the default implementation of the template class CStringT.

A CStringT object consists of a variable-length sequence of characters. CStringT provides functions and operators using a syntax similar to that of Basic. Concatenation and comparison operators, together with simplified memory management, make CStringT objects easier to use than ordinary character arrays.

Это из MSDN 2005

вот эта запись

Код:

CString::operator LPCTSTR() const

означает, что оператор (который сам является константной функцией) возвращает указатель на константный!!! буфер (ну написано же LPCTSTR, вот буква "С" означает константный)

С банкнотой
ВОТ!!!! Наконецто!!!! ты сам к этому пришел, что надо использовать мою банкноту только для чтения (если надо исправить, то делвем копию), потому что я давал тебе ее для чтения (и очень надеялся что так оно и будет)!!!! О чем я и толковал аж со вчера.

[Scorp__)]

Алексей1153++, lapulya, спор про ОЗУ в принципе не к месту )) Потому что один пытается сказать, что на низком уровне в ОЗУ все можно поменять - это верно, а второй говорит про абстракцию довольно высокого уровня, где существуют объекты, защищенные и константые области памяти и для абстракции тоже все верно.

Алексей1153++, ты же пишешь на С++, а не в машинных кодах и не на ассемблере, вот и соблюдай правила языка: сказано, что константа, значит константа, думай как обойти, в конце концов скопировать никто не запрещает. )) Честно говоря, я не понимаю, почему вообще разрешено к неконстанте приводить константу. Получается, что то что один построил, другой может запросто сломать, написав лишнее преобразование.

[Алексей++]

вот тебе лекарство для твоей болезни

про это я в курсе, но это не всегда поможет. К примеру , в константу надо загнать выражение, которое вычислится в конструкторе. Тогда делаем так:

Код:

A::A(int val_in) : i(0)
{
  //вычисляем
  //присваиваем через неконстантный указатель
}

CStringT

при чём тут CStringT ? Речь не про шаблоны , а про CString

ВОТ!!!! Наконецто!!!! ты сам к этому пришел, что надо использовать мою банкноту только для чтения (если надо исправить, то делвем копию), потому что я давал тебе ее для чтения (и очень надеялся что так оно и будет)!!!! О чем я и толковал аж со вчера.

это не я, это ты тут пришёл наконец к такому выводу Я как раз со вчера говорю, что я сделал крерокопию сначала


Scorp__), эт всё понятно, я к копированию и пришёл таки )  А разрешено приведение константы к не константе для гибкости , хотя в чужой класс, согласен, лезть так нельзя. Но не в случае CString )

[lapulya]

Ну тогда так

Код:

class A
{
	const int i;
public:
   A (int);
   int init(int);
};

A::A(int param) : i (g(param))
{}

int A::init(int i)
{return ++i;}

да в своем классе не так страшно, но зачем когда можно все сделать честно?

Про CString, я же написал
CString, which is the default implementation of the template class CStringT

А про купюру ты как раз ксерокопию делать не стал (ты не забывай, что ты изменял реальный константный буфер CString, а не копию этого буфера)

[Алексей++]

Код:

Ну тогда так

да ну , некрасиво

Код:

Про CString, я же написал
CString, which is the default implementation of the template class CStringT

у меня в студии CString - это класс, а не шаблонный класс, а про CStringT упоминания вообще нету Так что, не надо сюда некий CStringT приплетать

Код:

А про купюру ты как раз ксерокопию делать не стал

но я же стал делать копию, когда понял причину ошибки

[lapulya]

Алексей1153++ ,
ты пишешь

у меня в студии CString - это класс, а не шаблонный класс, а про CStringT упоминания вообще нету  Так что, не надо сюда некий CStringT приплетать

ну нету у меня MSDN от 6 версии студии, только от 2005 , а там нет понятия CString, ну что я могу поделать...  :dontknow:я ж про смысл, а не про придирки...

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

[Алексей++]

lapulya, а я не про мсдн, там то чёта мелькает, а в студии нет упоминания - я не нашёл, по крайней мере

[lapulya]

Алексей1153++, короче пушистый ))) я так понял ты будешь свою точку зрения до хрипоты отстаивать (ну если только тебя к стене не припереть), а если тебе только покажется что и честь... тьфу ты... MFC чем то задета или ее высокий идеал кто-то пытается затмить ))), то... смерть неверующим и аккупантам ... мдя.... о как меня занесло.

Так вот отвлечемся, что бы тебе было комфортно, то я вот так скажу...
std::string это не просто "дабы инкапсулировать строку, заканчивающуюся нулём", а класс работы со строковыми данными и ни как не меньше. Не забываем что и стринги и алгоритмы и еще до болта фишечек stl об этом знают и работают именно со строкой.

Более того стандарт открыто заявляет, что НЕТ ГАРАНТИИ, что хранение данных строки будет имнно в едином буфере (читай массиве типа char)!!!! Гарантировано лишь, что функция const char * c_str() возвращяет поинтер на константный единый буфер со строкой, контент которой инкапсулирован в объекте типа std::string

[Алексей++]

lapulya, начнём с того, что хрипота в голосе уже у тебя ) судя по количеству троеточий и восклицательных знаков.
Во вторых, честь MFC и так не нуждается в защите, хыхы, просто я стараюсь указать тебе на заблуждения по поводу класса CString (а кашу ты первый начал, и не вали на меня, что я привёл указатель к char* первый )
И третье:
CString - класс работы со строковыми данными и ни как не меньше.(c) И докажи обратное. И устроен он проще простого, а от количества методов содержимое класса не меняется. Простота - залог здоровья

ффот.

[Scorp__)]

Алексей1153++, да тут не в классе CString дело-то, а в стандартах программирования на данном языке. Что там в этом классе малоинтересно и для чего он - тоже.
Это как правило: переходить дорогу только на зеленый свет или по зебре. В принципе, ты можешь перейти дорогу в любом месте и сказать, что там одна машина в час проезжает и ты десять раз посмотрел и вообще ты по этой улице всю жизнь ходишь и профессионал и можешь сам решать где тебе улицы переходить. Но потенциально такое поведение может привести к тому, что машина тебя таки собьет, или велосипедист, которого ты не заметил или скутерист.

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

[Алексей++]

Scorp__), а я соблюдаю
(это я не про дороги)

[Scorp__)]

Вот и хорошо