Возможна ли инициализация const-строки не в конструкторе?

Question

[grey42]

Такой вопрос.

У меня есть некий класс со строковым полем (unsigned char* str). Это поле инициализируется не в конструкторе, а в одном из методов класса. Хотелось бы сделать поле (unsigned char* const), чтобы при вызове его get-функции был можно было получить указатель на данную строку, но не давать возможность изменять данные, которые были записаны при инициализации.


Существует ли какой-нибудь способ это сделать малой кровью? Если все оставлять как есть, то компилятор ругается на то, что инициализации при объявлении и в конструкторе нет. Если добавить ее в конструктор (str = NULL), то затем, соответственно, данные менять будет уже невозможно.


Плюс к тому, есть такая ремарка, инициализация происходит следующим образом:


В методе получается указатель на TCHAR*, который затем преобразуется к char*, который явно кастуется в unsigned char*. Получив указатель на данную строку (она временная и имеет смысл только в рамках инициализатора), вызывается str = new [*длина строки*]; а затем memcpy копирует одно в другое. Таким образом, происходит двойное присвоение, сначала str = new, затем memcpy(str,...). Можно ли прямо здесь умереть с мечтой иметь константные данные?


P.S. std::string не используется намеренно. Но если других вариантов нет, замена на него возможна, но желательно, чтобы get-метод все равно возвращал unsigned char* const.


Заранее спасибо за помощь.

Comments

[ixSci]

Можно кодом? мало что понятно из Вашего опуса

Answer 1

[Sveolon]

Краткий ответ на вопрос из названия — нет, нельзя. Но если я правильно понял задачу — избежать возможности модификации, то решений можно придумать несколько — отдавать копию по значению (тут хорошо подойдёт std::string), принимать в get параметром указатель на строку-приёмник и копировать туда, копировать в константный буфер, созданный тут же на стеке и отдавать указатель на него…

Comments

[grey42]

О, спасибо.

Answer 2

[gribozavr]

const члены, а также члены, являющиеся references, обязательно инициализировать в конструкторе.

Answer 3

[Константин Власов]

Не совсем понятно, почему константным должен стать указатель, если хочется запретить менять записанные по нему данные, а не его самого. То ли неточность в описании, то ли хотел сказать не unsigned char* const, а const unsigned char*. Но независимо от этого, атрибут const можно обойти модификатором const_cast (или банальным Си-подобным приведением типа). Главное при этом, чтобы приводимая память не оказалась в read-only области, но если она явно выделяется по new, то такого казуса, по идее, произойти не должно.

Comments

[grey42]

Насколько я помню, то, что справа от "*" относится к данным. Значит к моему случаю все же unsigned char* const нужен.

А можно подробнее про const_cast? Я пробовал unsigned char* GetStr() { return const_cast<BYTE*>(str); }, но данные все равно можно менять по этому указателю.

[Владислав]

Вы неправильно понимаете, смотрите мой комментарий ниже.

вам надо:

class A
{
private:
usigned const char *str;
…
usigned const char *get() const{ retutn str; }
};

p.s.
это все одно и то же (изменяемый указатель на неизменяемые данные):
unsigned const char *
const unsigned char *
unsigned char const *

[skor]

Автор вопроса не понимает две вещи в c++:
1) разницу между

unsigned char* const

и

unsigned char const *

2) что данные, помеченные как константные, но фактчески такими не являющиеся, можно изменить при желании.

[grey42]

1) Ну, я с С++ только в университете работал и то очень-очень мало. Главная беда в том, что эту разницу прочитал в статье, где перепутано местами было (слева от * к указателю, справа — к данным, что неверно). Оттуда и косяки с описанием.

2) Явный каст, да, позволит все менять. А каким образом сделать, чтобы они таковыми являлись?

[Владислав]

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

[grey42]

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

[Владислав]

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

[grey42]

Окей, спасибо за совет :)

Answer 4

[Владислав]

unsigned char* const — это константный указатель на изменяемый массив char

вам нужен

const unsigned char * — неконстантный указатель на неизменяемый массив char

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

пруф: habrahabr.ru/post/100104/

Answer 5

[Владислав]

>> Таким образом, происходит двойное присвоение, сначала str = new, затем memcpy(str,...).
никакого двойного присваивания не происходит

str = new unsigned char[size];

только выделяет память и запоминает, где эта память выделена, сама память не инициализируется.

копирование данных происходит внутри memcpy.

справедливости ради, если у вас typeof( str ) == typeof( usigned const char * ), то вы не сможете вызвать memcpy без приведения типа, т.к. у вас указатель на неизменяемые данные.

вам надо:

class A
{
private:
unsigned const char *str;
A(): str( nullptr ) // можно и не инициализировать в принципе, если уверены,
// что не будете читать его до инициализации
{
}
init(… )
{
unsigned char *ptr = new unsigned char[size];
memcpy( ptr,… );
str = ptr; // сами данные вы тут не меняете, только указатель на данные
}
usigned const char *get() const{ return str; }
};