Форум программистов, компьютерный форум CyberForum.ru

Что за перегруженный оператор char* ()? - C++

Восстановить пароль Регистрация
 
 
Рейтинг: Рейтинг темы: голосов - 58, средняя оценка - 4.66
kravam
быдлокодер
 Аватар для kravam
1513 / 873 / 44
Регистрация: 04.06.2008
Сообщений: 5,299
19.10.2010, 21:04     Что за перегруженный оператор char* ()? #1
Вот синтаксис:
C++
1
2
operator char*(){
                return ptr;
Пример взят из книги Брайана Овереленда и к этому примру, в частности, никаких пояснений

Я порылся в инете, но везде ведётся речь про перегружаемые оператооры, т есть примерно такого вида:
C++
1
[FONT=Times New Roman, Times, serif][SIZE=3]void operator-(char); [/SIZE][/FONT]
Ну, в общем, я сам не смогу разобраться с синтаксисом приведённого первого примера. Написано лишь, что:
"...Класс такой-то объявляет функцию преобразования char *() (а где её имя? где аргументы? Где возвращаемое значение?)
Если эта функция объявлена, вы можете использовать объект класса такого-то везде, где ожидаются данные типа char*.
Функция преобразования возвращает адрес строковых данных, которые содержатся в объекте данных ptr"

Просто помогите сие изложение осилить, спасибо.
Лучшие ответы (1)
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
taras atavin
Ушёл с форума.
 Аватар для taras atavin
3569 / 1752 / 91
Регистрация: 24.11.2009
Сообщений: 27,619
20.10.2010, 06:13     Что за перегруженный оператор char* ()? #61
Цитата Сообщение от KuKu Посмотреть сообщение
а то что возвращаемого значения нету это нормально
А какой ещё тип возвращаемого значения может в принципе быть у опретора приведения к типу? Потому и не указывается.
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
#pragma
Временно недоступен
 Аватар для #pragma
952 / 223 / 6
Регистрация: 12.04.2009
Сообщений: 921
20.10.2010, 20:52     Что за перегруженный оператор char* ()? #62
Цитата Сообщение от Mr.X Посмотреть сообщение
... , а запись
C++
1
T(value)
– это явный вызов конструктора, которые в C++ формально введены и для встроенных типов.
...
запись
C++
1
T(value)
для встроенных типов всегда означает
C++
1
static_cast<T>(value)
.
Добавлено через 5 минут
Я неточно выразился. Я хотел сказать может означать любое преобразование, которое может быть выражено комбинацией static_cast, reinterpret_cast и const_cast.
Я Вас не понял,всё-таки конструктор или приведение типа?
Mr.X
Эксперт С++
 Аватар для Mr.X
3011 / 1667 / 265
Регистрация: 03.05.2010
Сообщений: 3,867
20.10.2010, 21:14     Что за перегруженный оператор char* ()? #63
Цитата Сообщение от #pragma Посмотреть сообщение
Я Вас не понял,всё-таки конструктор или приведение типа?
Для пользовательских типов – вызов соответствующего конструктора, а для встроенных – static_cast (то, что там было добавлено через 5 минут – ответ совсем на другое сообщение, просто здесь последовательные сообщения склеиваются).
kravam
быдлокодер
 Аватар для kravam
1513 / 873 / 44
Регистрация: 04.06.2008
Сообщений: 5,299
21.10.2010, 19:21  [ТС]     Что за перегруженный оператор char* ()? #64
Ребята. ну неужели никто не может сказать? Везде, где есь список перегружаемых операторов
char*() не входит в их число.

ТО есть ищем в интернете список перегружаемых операторов в С++. И если такой список найдётся, вы не увидите в нём оператора char*()

Так почему же это выражение синтаксически верно?
C++
1
operator char*() {return ptr;}
ForEveR
Модератор
Эксперт С++
 Аватар для ForEveR
7954 / 4716 / 318
Регистрация: 24.06.2010
Сообщений: 10,525
Завершенные тесты: 3
21.10.2010, 19:22     Что за перегруженный оператор char* ()? #65
kravam, Потому что это оператор приведения типа................

С 53 слайда перегрузка оператора приведения типа
KuKu
 Аватар для KuKu
1544 / 1022 / 69
Регистрация: 17.04.2009
Сообщений: 2,954
21.10.2010, 19:27     Что за перегруженный оператор char* ()? #66
Уже 10 раз сказали, что это. А не найдете потому, что приведение к типа char* быть может не так часто используется. Гугл правда на фразу operator char* имеет другое мнение.
Andrew_Lvov
Эксперт C++
 Аватар для Andrew_Lvov
259 / 189 / 5
Регистрация: 19.08.2010
Сообщений: 758
Записей в блоге: 1
21.10.2010, 19:31     Что за перегруженный оператор char* ()? #67
Хаха!! Даже operator void() есть )

Добавлено через 1 минуту
Цитата Сообщение от KuKu Посмотреть сообщение
А не найдете потому, что приведение к типа char* быть может не так часто используется.
По меньшей мере CString. Правда, у него приведение к LPCTSTR, то есть const TCHAR*. TCHAR - это либо char, либо WCHAR.
kravam
быдлокодер
 Аватар для kravam
1513 / 873 / 44
Регистрация: 04.06.2008
Сообщений: 5,299
21.10.2010, 19:34  [ТС]     Что за перегруженный оператор char* ()? #68
Да как вы не поймёте, на данном этапе мне всё равно, что это такое. Почему оно здесь- вот что меня интересует. ..Как я буду нечто подобное применять, если нигде не прочёл правила применения?

Вот к примеру, книга Стивена Прата "Язык программирования С++"
Глава 11 и там перечень операций, которые могут быть перегружены

char* () там нет

Дайте мне ссыль где расписывается подобный синтаксис и я отстану. Я нигде в упор не вижу. Вездде только
C++
1
operator<какой-нибудь допустимый для перегрузки орератор>
.
ForEveR
Модератор
Эксперт С++
 Аватар для ForEveR
7954 / 4716 / 318
Регистрация: 24.06.2010
Сообщений: 10,525
Завершенные тесты: 3
21.10.2010, 19:35     Что за перегруженный оператор char* ()? #69
kravam, Я ж написал ссылку выше... с 53 слайда немного объясняется.
kravam
быдлокодер
 Аватар для kravam
1513 / 873 / 44
Регистрация: 04.06.2008
Сообщений: 5,299
21.10.2010, 19:37  [ТС]     Что за перегруженный оператор char* ()? #70
Ну по фиг пусть там будет вемето char int или double
Мне важно прочесть: такая-то херь применяется по таким-то и таким-то правилам

...У меня в учебнике, например. эти правила не описаны, а сразу приведён пример, будто я гений какой-то.
ForEveR
Модератор
Эксперт С++
 Аватар для ForEveR
7954 / 4716 / 318
Регистрация: 24.06.2010
Сообщений: 10,525
Завершенные тесты: 3
21.10.2010, 19:44     Что за перегруженный оператор char* ()? #71
kravam, Скорее потому, что это не столь часто используется. Приведение типов аще опасно и не рекомендуется.

Добавлено через 4 минуты
Цитата.

Значительно удобнее автоматически преобразовать объект класса SmallInt в объект типа int.

В языке C++ имеется механизм, позволяющий в любом классе задать набор преобразований, применимых к его объектам. Для SmallInt мы определим приведение объекта к типу int. Вот его реализация:

class SmallInt {
public:
SmallInt(int ival) : value(ival) {}

// конвертер
// SmallInt ==> int
operator int() {return value;}

// перегруженные операторы не нужны

private:
int value;
};

Оператор int() – это конвертер, реализующий определенное пользователем преобразование, в данном случае приведение типа класса к заданному типу int. Определение конвертера описывает, что означает преобразование и какие действия компилятор должен выполнить для его применения. Для объекта SmallInt смысл преобразования в int заключается в том, чтобы вернуть число типа int, хранящееся в члене value.

Теперь объект класса SmallInt можно использовать всюду, где допустимо использование int. Если предположить, что перегруженных операторов больше нет и в SmallInt определен конвертер в int, операция сложения
kravam
быдлокодер
 Аватар для kravam
1513 / 873 / 44
Регистрация: 04.06.2008
Сообщений: 5,299
21.10.2010, 19:46  [ТС]     Что за перегруженный оператор char* ()? #72
Да мне всё равно, я дальше в обучении продвинуться не могу. Люди добрые дайте мне ссыль на ресурс, я сам не найду, где подобный синтаксис был бы разъяснён. Не может же быть, чтобы он нигде не был разъяснён СКОЛЬ РЕДКО БЫ ОН НЕ ПРИМЕНЯЛСЯ!

http://www.slideboom.com/presentatio...86%D0%B8%D0%B9

Тут нет, перегрузка обыкновенных "+" и "-", кои я найду в любом учебнике.
...Изучаю вышенаписанный пост
ForEveR
Модератор
Эксперт С++
 Аватар для ForEveR
7954 / 4716 / 318
Регистрация: 24.06.2010
Сообщений: 10,525
Завершенные тесты: 3
21.10.2010, 19:47     Что за перегруженный оператор char* ()? #73
И еще...

Ишо цитата
15.9.1. Конвертеры

Конвертер – это особый случай функции-члена класса, реализующий определенное пользователем преобразование объекта в некоторый другой тип. Конвертер объявляется в теле класса путем указания ключевого слова operator, за которым следует целевой тип преобразования.

Имя, находящееся за ключевым словом, не обязательно должно быть именем одного из встроенных типов. В показанном ниже классе Token определено несколько конвертеров. В одном из них для задания имени типа используется typedef tName, а в другом – тип класса SmallInt.

#include "SmallInt.h"
typedef char *tName;
class Token {
public:
Token(char *, int);
operator SmallInt() {return val;}
operator tName() {return name;}
operator int() {return val;}
// другие открытые члены
private:
SmallInt val;
char *name;
};

Обратите внимание, что определения конвертеров в типы SmallInt и int одинаковы. Конвертер Token::operator int() возвращает значение члена val. Поскольку val имеет тип SmallInt, то неявно применяется SmallInt::operator int() для преобразования val в тип int. Сам Token::operator int() неявно употребляется компилятором для преобразования объекта типа Token в значение типа int. Например, этот конвертер используется для неявного приведения фактических аргументов t1 и t2 типа Token к типу int формального параметра функции print():

#include "Token.h"
void print(int i)
{
cout < < "print(int) : " < < i < < endl;
}
Token t1("integer constant", 127);
Token t2("friend", 255);
int main()
{
print(t1); // t1.operator int()
print(t2); // t2.operator int()
return 0;
}

После компиляции и запуска программа выведет такие строки:

print(int) : 127
print(int) : 255

Общий вид конвертера следующий:

operator type();

где type может быть встроенным типом, типом класса или именем typedef. Конвертеры, в которых type – тип массива или функции, не допускаются. Конвертер должен быть функцией-членом. В его объявлении не должны задаваться ни тип возвращаемого значения, ни список параметров:

operator int(SmallInt &); // ошибка: не член
class SmallInt {
public:
int operator int(); // ошибка: задан тип возвращаемого значения
operator int(int = 0); // ошибка: задан список параметров
// ...
};
Конвертер вызывается в результате явного преобразования типов. Если преобразуемое значение имеет тип класса, у которого есть конвертер, и в операции приведения указан тип этого конвертера, то он и вызывается:

#include "Token.h"
Token tok("function", 78);

// функциональная нотация: вызывается Token::operator SmallInt()
SmallInt tokVal = SmallInt(tok);
// static_cast: вызывается Token::operator tName()
char *tokName = static_cast< char * >(tok);

У конвертера Token::operator tName() может быть нежелательный побочный эффект. Попытка прямого обращения к закрытому члену Token::name помечается компилятором как ошибка:

char *tokName = tok.name; // ошибка: Token::name - закрытый член

Однако наш конвертер, разрешая пользователям непосредственно изменять Token::name, делает как раз то, от чего мы хотели защититься. Скорее всего, это не годится. Вот, например, как могла бы произойти такая модификация:

#include "Token.h"
Token tok("function", 78);
char *tokName = tok; // правильно: неявное преобразование
*tokname = 'P'; // но теперь в члене name находится Punction!

Мы намереваемся разрешить доступ к преобразованному объекту класса Token только для чтения. Следовательно, конвертер должен возвращать тип const char*:

typedef const char *cchar;
class Token {
public:
operator cchar() {return name;}
// ...
};
// ошибка: преобразование char* в const char* не допускается
char *pn = tok;
const char *pn2 = tok; // правильно

Другое решение – заменить в определении Token тип char* на тип string из стандартной библиотеки C++:

class Token {
public:
Token(string, int);
operator SmallInt() {return val;}
operator string() {return name;}
operator int() {return val;}
// другие открытые члены
private:
SmallInt val;
string name;
};

Семантика конвертера Token::operator string() состоит в возврате копии значения (а не указателя на значение) строки, представляющей имя лексемы. Это предотвращает случайную модификацию закрытого члена name класса Token.

Должен ли целевой тип точно соответствовать типу конвертера? Например, будет ли в следующем коде вызван конвертер int(), определенный в классе Token?

extern void calc(double);
Token tok("constant", 44);
// Вызывается ли оператор int()? Да
// применяется стандартное преобразование int --> double
calc(tok);

Если целевой тип (в данном случае double) не точно соответствует типу конвертера (в нашем случае int), то конвертер все равно будет вызван при условии, что существует последовательность стандартных преобразований, приводящая к целевому типу из типа конвертера. (Эти последовательности описаны в разделе 9.3.) При обращении к функции calc() вызывается Token::operator int() для преобразования tok из типа Token в тип int. Затем для приведения результата от типа int к типу double применяется стандартное преобразование.

Вслед за определенным пользователем преобразованием допускаются только стандартные. Если для достижения целевого типа необходимо еще одно пользовательское преобразование, то компилятор не применяет никаких преобразований. Предположим, что в классе Token не определен operator int(), тогда следующий вызов будет ошибочным:

extern void calc(int);
Token tok("pointer", 37);
// если Token::operator int() не определен,
// то этот вызов приводит к ошибке компиляции
calc(tok);

Если конвертер Token::operator int() не определен, то приведение tok к типу int потребовало бы вызова двух определенных пользователем конвертеров. Сначала фактический аргумент tok надо было бы преобразовать из типа Token в тип SmallInt с помощью конвертера

Token::operator SmallInt()

а затем результат привести к типу int – тоже с помощью пользовательского конвертера

Token::operator int()

Вызов calc(tok) помечается компилятором как ошибка, так как не существует неявного преобразования из типа Token в тип int.

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

class Date {
public:
// попробуйте догадаться, какой именно член возвращается!
operator int();
private:
int month, day, year;
};

Какое значение должен вернуть конвертер int() класса Date? Сколь бы основательными ни были причины для того или иного решения, читатель останется в недоумении относительно того, как пользоваться объектами класса Date, поскольку между ними и целыми числами нет явного логического соответствия. В таких случаях лучше вообще не определять конвертер.

И еще...
15.9.2.Конструктор как конвертер

Набор конструкторов класса, принимающих единственный параметр, например, SmallInt(int) класса SmallInt, определяет множество неявных преобразований в значения типа SmallInt. Так, конструктор SmallInt(int) преобразует значения типа int в значения типа SmallInt.

extern void calc(SmallInt);
int i;
// необходимо преобразовать i в значение типа SmallInt
// это достигается применением SmallInt(int)
calc(i);
При вызове calc(i) число i преобразуется в значение типа SmallInt с помощью
конструктора SmallInt(int), вызванного компилятором для создания временного
объекта нужного типа. Затем копия этого объекта передается в calc(), как
если бы вызов функции был записан в форме:
// Псевдокод на C++
// создается временный объект типа SmallInt
{
SmallInt temp = SmallInt(i);
calc(temp);
}

Фигурные скобки в этом примере обозначают время жизни данного объекта: он уничтожается при выходе из функции.

Типом параметра конструктора может быть тип некоторого класса:

class Number {
public:
// создание значения типа Number из значения типа SmallInt
Number(const SmallInt &);
// ...
};

В таком случае значение типа SmallInt можно использовать всюду, где допустимо значение типа Number:

extern void func(Number);
SmallInt si(87);

int main()
{// вызывается Number(const SmallInt &)
func(si);
// ...
}

Если конструктор используется для выполнения неявного преобразования, то должен ли тип его параметра точно соответствовать типу подлежащего преобразованию значения? Например, будет ли в следующем коде вызван SmallInt(int), определенный в классе SmallInt, для приведения dobj к типу SmallInt?

extern void calc(SmallInt);
double dobj;

// вызывается ли SmallInt(int)? Да
// dobj преобразуется приводится от double к int
// стандартным преобразованием
calc(dobj);

Если необходимо, к фактическому аргументу применяется последовательность стандартных преобразований до того, как вызвать конструктор, выполняющий определенное пользователем преобразование. При обращении к функции calc()употребляется стандартное преобразование dobj из типа double в тип int. Затем уже для приведения результата к типу SmallInt вызывается SmallInt(int).

Компилятор неявно использует конструктор с единственным параметром для преобразования его типа в тип класса, к которому принадлежит конструктор. Однако иногда удобнее, чтобы конструктор Number(const SmallInt&) можно было вызывать только для инициализации объекта типа Number значением типа SmallInt, но ни в коем случае не для выполнения неявных преобразований. Чтобы избежать такого употребления конструктора, объявим его явным (explicit):

class Number {
public:
// никогда не использовать для неявных преобразований
explicit Number(const SmallInt &);
// ...
};

Компилятор никогда не применяет явные конструкторы для выполнения неявных преобразований типов:

extern void func(Number);
SmallInt si(87);

int main()
{// ошибка: не существует неявного преобразования из SmallInt в Number
func(si);
// ...
}

Однако такой конструктор все же можно использовать для преобразования типов, если оно запрошено явно в форме оператора приведения типа:

SmallInt si(87);

int main()
{// ошибка: не существует неявного преобразования из SmallInt в Number
func(si);
func(Number(si)); // правильно: приведение типа
func(static_cast< Number >(si)); // правильно: приведение типа
}

15.10. Выбор преобразования A

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

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

Последовательность стандартных преобразований ->

Определенное пользователем преобразование ->

Последовательность стандартных преобразований

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

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

В классе разрешается определять много конвертеров. Например, в нашем классе Number их два: operator int() и operator float(), причем оба способны преобразовать объект типа Number в значение типа float. Естественно, можно воспользоваться конвертером Token::operator float() для прямой трансформации. Но и Token::operator int() тоже подходит, так как результат его применения имеет тип int и, следовательно, может быть преобразован в тип float с помощью стандартного преобразования. Является ли трансформация неоднозначной, если имеется несколько таких последовательностей? Или какую-то из них можно предпочесть остальным?

class Number {
public:
operator float();
operator int();
// ...
};
Number num;
float ff = num; // какой конвертер? operator float()

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

1. operator float() -> точное соответствие
2. operator int() -> стандартное преобразование

Как было сказано в разделе 9.3, точное соответствие лучше стандартного преобразования. Поэтому первая последовательность лучше второй, а значит, выбирается конвертер Token::operator float().

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

class SmallInt {
public:
SmallInt(int ival) : value(ival) {}
SmallInt(double dval)
: value(static_cast< int >(dval));
{}
};

extern void manip(const SmallInt &);
int main() {
double dobj;
manip(dobj); // правильно: SmallInt(double)
}

Здесь в классе SmallInt определено два конструктора – SmallInt(int) и SmallInt(double), которые можно использовать для изменения значения типа double в объект типа SmallInt: SmallInt(double) трансформирует double в SmallInt напрямую, а SmallInt(int) работает с результатом стандартного преобразования double в int. Таким образом, имеются две последовательности определенных пользователем преобразований:

1. точное соответствие -> SmallInt(double)
2. стандартное преобразование -> SmallInt(int)

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

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

class Number {
public:
operator float();
operator int();
// ...
};

то невозможно неявно преобразовать объект типа Number в тип long. Следующая инструкция вызывает ошибку компиляции, так как выбор последовательности определенных пользователем преобразований неоднозначен:

// ошибка: можно применить как float(), так и int()
long lval = num;

Для трансформации num в значение типа long применимы две такие последовательности:

1. operator float() -> стандартное преобразование
2. operator int() -> стандартное преобразование

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

С помощью явного приведения типов программист способен задать нужное изменение:

// правильно: явное приведение типа
long lval = static_cast<int >(num);

Вследствие такого указания выбирается конвертер Token::operator int(), за которым следует стандартное преобразование в long.

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

class SmallInt {
public:
SmallInt(const Number &);
// ...
};

class Number {
public:
operator SmallInt();
// ...
};

extern void compute(SmallInt);
extern Number num;

compute(num); // ошибка: возможно два преобразования

Аргумент num преобразуется в тип SmallInt двумя разными способами: с помощью конструктора SmallInt::SmallInt(const Number&) либо с помощью конвертера Number::operator SmallInt(). Поскольку оба изменения одинаково хороши, вызов считается ошибкой.

Для разрешения неоднозначности программист может явно вызвать конвертер класса Number:

// правильно: явный вызов устраняет неоднозначность
compute(num.operator SmallInt());

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

compute(SmallInt(num)); // ошибка: по-прежнему неоднозначно

Как видите, наличие большого числа подобных конвертеров и конструкторов небезопасно, поэтому их. следует применять с осторожностью. Ограничить использование конструкторов при выполнении неявных преобразований (а значит, уменьшить вероятность неожиданных эффектов) можно путем объявления их явными.
kravam
быдлокодер
 Аватар для kravam
1513 / 873 / 44
Регистрация: 04.06.2008
Сообщений: 5,299
21.10.2010, 19:50  [ТС]     Что за перегруженный оператор char* ()? #74
Ну вот, вот оно самое. Дайте пожалуйста ссыль на эту цитату
KuKu
 Аватар для KuKu
1544 / 1022 / 69
Регистрация: 17.04.2009
Сообщений: 2,954
21.10.2010, 19:50     Что за перегруженный оператор char* ()? #75
kravam, у вас есть класс Stroka - вы его написали сами, а содержится в нем массив букв.
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Stroka
{
private: 
   char* text; // сами буквы
   int lenght; // длина слова
   char* sdfdf; // какая то ваша переменная 
public:
  Stroka()
 {
  lenght =4;
  text=new char[lenght];
  text="MAMA";
}
operator char*();
 {
   return (text);
 }
};
во время работы вы хотите вывести содержание своей строки.
вы пишите
C++
1
2
Stroka s;
cout <<s << endl;
Но компилятор не умеет выводить тип Stroka. Но он умеет выводить тип сhar*. И вы с радостью пишете

C++
1
cout << ((char*)s) << endl;
вот примерно так.
ForEveR
Модератор
Эксперт С++
 Аватар для ForEveR
7954 / 4716 / 318
Регистрация: 24.06.2010
Сообщений: 10,525
Завершенные тесты: 3
21.10.2010, 19:52     Что за перегруженный оператор char* ()? #76
KuKu, Лучше геттер написать в таком случае. ИМХО
KuKu
 Аватар для KuKu
1544 / 1022 / 69
Регистрация: 17.04.2009
Сообщений: 2,954
21.10.2010, 19:54     Что за перегруженный оператор char* ()? #77
Цитата Сообщение от Lavroff Посмотреть сообщение
KuKu, Лучше геттер написать в таком случае. ИМХО
У ТС проблема нафига нужно это operator char*() , имхо это как раз то, что нужно для пояснения зачем, не надо смущать его лишней информацией .
kravam
быдлокодер
 Аватар для kravam
1513 / 873 / 44
Регистрация: 04.06.2008
Сообщений: 5,299
21.10.2010, 20:01  [ТС]     Что за перегруженный оператор char* ()? #78
ВСё, нашёл я источник сам
http://valera.asf.ru/cpp/book/c15.shtml
Уф, семь потов сошло.
Спасибо.

Добавлено через 5 минут
Цитата Сообщение от KuKu Посмотреть сообщение
У ТС проблема нафига нужно это operator char*() , имхо это как раз то, что нужно для пояснения зачем, не надо смущать его лишней информацией .
Да в том-то и дело, что я примерно на фига знаю. Преобразование строки к типу "указатель на char" Ну или приведение типа- неважно щас

Но нет объяснения этого синтаксиса, а коль скоро я привык по другому приведение делать, (используя скобки), то вот вопросы и возникли. Ну, извините, не мог я сам найти инфы в инете. Но мне помогли, Бог даст, дальше сам разберусь. И повторюсь в моём учебнике сей пример БЕЗО ВСЯКОГО ОБЪЯСНЕНИЯ. Типа "догадайся сам" вот я думал- не подвох ли тут какой-нибудь. Ну допусти я с самого начала что это учебник такой... э... с изъяном может быть сразу ПО ДРУГОМУ построил поиск к в инете. ВСем спасибо, тему к закрытию можно.
#pragma
Временно недоступен
 Аватар для #pragma
952 / 223 / 6
Регистрация: 12.04.2009
Сообщений: 921
22.10.2010, 21:25     Что за перегруженный оператор char* ()? #79
Цитата Сообщение от Andrew_Lvov Посмотреть сообщение
Нет, конструировать указатель первым способом нельзя.
Видимо,всё-таки можно.
C++
1
2
        int *u(NULL);
        assert(u != NULL);
Но неявное приведение типов походу не работает,то есть если попытаться послать что-то вроде 0xff (якобы адрес).
А послать адрес переменной или указатель - пожалуйста,всё работает,по крайней мере,с моим компилятором (gcc)
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
23.10.2010, 15:49     Что за перегруженный оператор char* ()?
Еще ссылки по теме:

Функтор и перегруженный оператор C++
C++ Перегруженный оператор вывода
C++ Перегруженный оператор
Перегруженный постфиксный оператор ++ C++
Глобальный перегруженный оператор C++

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
Andrew_Lvov
Эксперт C++
 Аватар для Andrew_Lvov
259 / 189 / 5
Регистрация: 19.08.2010
Сообщений: 758
Записей в блоге: 1
23.10.2010, 15:49     Что за перегруженный оператор char* ()? #80
Цитата Сообщение от #pragma Посмотреть сообщение
Видимо,всё-таки можно.
Возможно я неясно выразился. Речь шла о том, что вместо конструирования указателя из z будет обьявление переменной с названием "z" и типом char*. Речь шла о коде:
C++
1
2
char*(z);
(char*)z;
Инициализировать, как вы указали, конечно же можно. Например:
C++
1
2
3
    char* (z)(NULL);
    z = "hello, team!";
    cout << z;
Правда, код выше я не в коем случае не рекомендую как пример для подражания - такой код только запутает читателя.
Yandex
Объявления
23.10.2010, 15:49     Что за перегруженный оператор char* ()?
Ответ Создать тему
Опции темы

Текущее время: 23:48. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru