Указатель на ссылку или что это такое?

@Undisputed · Регистрация: 10.06.2014

Студворк — интернет-сервис помощи студентам

C++
1
void add(char aData, Branch *&aBranch);

Речь об аргументе aBranch.
Как это понимать? Указатель на ссылку? Не понятно. Вроде такое не имеет смысла
Или это своего рода упрощенное использование указателя на указатель?
Прошу объяснить

Добавлено через 6 минут
На СИшном компиляторе не компилится... Значит плюсовая фича
Но чего оно делает?

@Achill · 24.12.2018, 01:54

Сообщение от DrOffset

Первый аргумент - это std::cout. Запись std::cout << a; - это синтаксический сахар для вот такого вызова operator<<(std::cout, a);.

В случае, если мы говорим о встроенных версиях * и & (т.е. об отсутствии их перегрузок) компилятор не порождает дополнительных инструкций для такой записи. Т.е. да, в вашем случае это эквивалентно.

В обобщенных алгоритмах, например при работе с итераторами, эта запись поможет вытащить настоящий адрес элемента. Там это важно как раз из-за возможной перегрузки operator* и\или operator&.

Спасибо, но если компилятор игнорирует обе операции "&*" и принимает только эквивалент просто "a" потому что не порождает дополнительных инструкций то например почему срабатывает такое "cout << *&*a" ? в итоге выводит уже 1 элемент, а не всю строку, и даже такое "cout << &*&*a"тут явно какую-то компилятор не проигнорил.
А в таком моменте происходит следующее:

C++
1
2
char r[10] = "hello";
char *s = &*r;

здесь указатель s получает адрес только первого элемента разыменованного указателя и все?
здесь уже ничего не игнорируется?
и еще вопрос
в перегруженной функции"cout<<" когда она принимает указатель и выводит всю строку до нуля терминатора, она получает адрес самого указателя, а не первого элемента?

@DrOffset · 24.12.2018, 11:21

Сообщение от Achill

о если компилятор игнорирует обе операции "&*" и принимает только эквивалент просто "a" потому что не порождает дополнительных инструкций то например почему срабатывает такое "cout << *&*a" ?

Компилятор не игнорирует.
Компилятор видит, что результаты выражений эквивалентны и не генерирует дополнительный бессмысленный код.
Ваше cout << *&*a; эквивалентно cout << *a;.
Предыдущие cout << &*a; эквивалентно cout << a;.
Естественно все это в силе, если мы говорим о встроенных версиях этих операторов. Если они перегружены, то в общем случае каждая операция будет выполнена.

Сообщение от Achill

C++
1
2
char r[10] = "hello"; 
char *s = &*r;

Лишних инструкций здесь также не будет. Т.е. это эквивалентно char * s = r;.
Эта ситуация ничем не отличается от варианта с cout. Почему вы решили будто бы здесь что-то будет иначе?

Сообщение от Achill

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

Это очень странная фраза. У указателя нет никаких "элементов".
Элементы есть у массива.
Указатель - это курсор. Он может указывать на один из элементов последовательности заданной массивом или на одиночный объект.
Возьмите листочек в клеточку, нарисуйте там карту для морского боя. Вы когда в морском бое делаете ход, называете координату клетки, например, А-1 - это и есть адрес. Если вы выделите клетку под эту запись A-1, то вы создаете переменную-указатель, которая содержит заданный адрес. Если вы выделили несколько клеток подряд, то получаете массив. Это же очень просто. Порисуйте, разберитесь.

Сообщение от Achill

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

Она получает адрес первого элемента (ну или любого другого, какой укажете). Главное, чтобы конец последовательности, в которую входит этот элемент, оканчивался байтом со значением "ноль". Иначе функция не будет иметь возможности остановить цикл.

@Achill · 24.12.2018, 13:20

Сообщение от DrOffset

Компилятор не игнорирует.
Компилятор видит, что результаты выражений эквивалентны и не генерирует дополнительный бессмысленный код.
Ваше cout << *&*a; эквивалентно cout << *a;.
Предыдущие cout << &*a; эквивалентно cout << a;.
Естественно все это в силе, если мы говорим о встроенных версиях этих операторов. Если они перегружены, то в общем случае каждая операция будет выполнена.

Лишних инструкций здесь также не будет. Т.е. это эквивалентно char * s = r;.
Эта ситуация ничем не отличается от варианта с cout. Почему вы решили будто бы здесь что-то будет иначе?

Это очень странная фраза. У указателя нет никаких "элементов".
Элементы есть у массива.
Указатель - это курсор. Он может указывать на один из элементов последовательности заданной массивом или на одиночный объект.
Возьмите листочек в клеточку, нарисуйте там карту для морского боя. Вы когда в морском бое делаете ход, называете координату клетки, например, А-1 - это и есть адрес. Если вы выделите клетку под эту запись A-1, то вы создаете переменную-указатель, которая содержит заданный адрес. Если вы выделили несколько клеток подряд, то получаете массив. Это же очень просто. Порисуйте, разберитесь.

Она получает адрес первого элемента (ну или любого другого, какой укажете). Главное, чтобы конец последовательности, в которую входит этот элемент, оканчивался байтом со значением "ноль". Иначе функция не будет иметь возможности остановить цикл.

Это выражение cout << *&*a; как можно трактовать? справа на лева 1) разыменование, 2) получение адреса разыменованного указателя, и снова разыменование это адреса Т.Е получает доступ по адресу полученному операцией &?
аналогично cout <<*a; а здесь cout << &*a; разыменование и получение адреса элемента на который указывает указатель, Т.Е тоже самое что cout <<a; потому что в этом выражении "а" так же содержит адрес первого элемента(не обязательно на первый элемент) Выглядит так, будто в этих выражениях операция & это обратное действие операции *

Это очень странная фраза. У указателя нет никаких "элементов".
"s получает адрес только первого элемента разыменованного(получение содержимого по адресу на который указывает указатель) указателя и все?"
char *s = &*r;
здесь я имел ввиду "s" получает адрес который получается в ходе 1)разыменование "r" 2)и получение адреса того элемента на который указывает указатель "r". В итоге это по логике тоже самое что просто char *s = r; потому что "r" так же содержит адрес первого элемента(первой ячейки если учитывать состояние указателя по "дефолту")

C++
1
2
char r[10] = "hello"; 
char *s = &*r;

т.к в этом случае он содержит адрес именно начала "0 индекса", и по этому раз это аналогично char *s = r; по этому компилятор не исполняет эти операции.

@DrOffset · 24.12.2018, 13:27

Сообщение от Achill

Выглядит так, будто в этих выражениях операция & это обратное действие операции *

Так и есть.

@Achill · 24.12.2018, 13:29

Сообщение от DrOffset

Так и есть.

Спасибо большое! Пока буду считать что я что - то в этом понял

@Achill · 16.01.2019, 15:43

подскажите пожалуйста на что указывает разыменованный *this здесь?

C++
1
++(*this);

на адрес конструктора(или на значение в конструкторе? тогда как ? и на какое?) или на переменную m_digit?
что получится если это заменить
просто

C++
1
++m_digit;

?

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <iostream>
using namespace std;
class Digit
{
 
private:
    int m_digit;
public:
    Digit(int ndigit=0){
     m_digit=ndigit;
                        }
    Digit& operator++();//prefix
    Digit& operator--();   //prefix
        Digit operator++(int);
        Digit operator--(int);
        int get() const { return m_digit;}
};
Digit& Digit::operator++(){
 
   ++m_digit;
   return *this;
}
Digit& Digit::operator--(){
 --m_digit;
 return *this;
 
}
Digit Digit::operator++(int){
Digit cresult(m_digit);
++(*this);
return cresult;
 
 
}
    Digit Digit::operator--(int){
Digit cresult(m_digit);
--(*this);
return cresult;
 
 
}
    int main(){
 
     Digit cDigit(5);
      ++cDigit;
        cDigit++;
         cout<<cDigit.get()<<endl;
         cout<<cDigit.get()<<endl;
 
 
 
 
 
     return 0;
    }
 
 
}

@eva2326 · 16.01.2019, 15:50

Сообщение от Achill

подскажите пожалуйста на что указывает разыменованный *this здесь?

что будет если разыменовать обычный указатель? получим объект на который указывает указатель.
что будет если разыменовать this указатель? получим объект на который указывает this.

на какой объект указывает this? на самого себя.
тогда что за объект получится после разыменования this? тот самый объект, для которого был применен this

@TRam_ · 16.01.2019, 16:08

Achill, в функции класса (методе) записи

C++
1
2
3
++m_digit;
++(this->m_digit);
++((*this).m_digit);

эквивалентны и означают работу с полем класса m_digit текущего объекта

Добавлено через 2 минуты
А запись

C++
1
++(*this);

эквивалентна

C++
1
operator++();

или что опять же то же самое

C++
1
(*this).operator++();

@Achill · 16.01.2019, 22:58

Сообщение от TRam_

Achill, в функции класса (методе) записи

C++
1
2
3
++m_digit;
++(this->m_digit);
++((*this).m_digit);

эквивалентны и означают работу с полем класса m_digit текущего объекта

Добавлено через 2 минуты
А запись

C++
1
++(*this);

эквивалентна

C++
1
operator++();

или что опять же то же самое

C++
1
(*this).operator++();

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

C++
1
++(*this);

вызовет вот этот перегруженный префиксный инкремент?

C++
1
2
3
4
5
Digit& Digit::operator++(){
 
   ++m_digit;
   return *this;
}

и еще 2 вопроса
если в префиксном инкременте с помощью перегруженного ++

C++
1
2
3
4
++a;
вызывается operator++(a);
 
тут все понятно переменная "a" находящаяся справа становится аргументом функции перегруженного оператора ++

то при постфиксном
как происходит вызов если вызов operator++ справа от переменной?

C++
1
2
3
4
b++;
 
b operator++(); ?
как это выглядит на самом деле?

следующий вопрос

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

ОШИБКА "error: statement cannot resolve address of overloaded function"

operator+(sterling s2){
sterling::operator+;

}

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class sterfrac:public sterling
{
 
protected:
 
        long pounds;
    int shilling;
    int pens;
    double decPounds = 0.0;
 
droby a,b;
char ch;
 
public:
 
    sterfrac():sterling(0,0,0){}
    sterfrac(sterling st):sterling(st){}
    sterfrac(double d):sterling(d){}
    sterfrac(long p, int sh, int pe):sterling(p,sh,pe){}
 
operator+(sterling s2){
  sterling::operator+;
 
   }

@TRam_ · 16.01.2019, 23:49

Сообщение от Achill

как происходит вызов если вызов operator++ справа от переменной?

Вот как раз operator++() это префиксный (т.е. ++a), не суффиксный
https://ru.wikipedia.org/wiki/... _и_C%2B%2B

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

Соответственно для a++ нужно вызвать

C++
1
2
int i;
operator++(i);

или

C++
1
operator++(0);

так как константа 0 по умолчанию является целочисленной, а единственная перегрузка оператора сама преобразует в int

Добавлено через 5 минут

Сообщение от Achill

ут все понятно переменная "a" находящаяся справа становится аргументом функции перегруженного оператора ++

Вот как раз это заблуждение. Порядок тут вообще не причём, смотри выше.

Сообщение от Achill

почему нельзя делать так?

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

C++
1
2
3
sterfrac operator+(sterling s2){
      return sterling::operator+(s2);
}

@Achill · 17.01.2019, 01:32

Сообщение от TRam_

Вот как раз operator++() это префиксный (т.е. ++a), не суффиксный
https://ru.wikipedia.org/wiki/... _и_C%2B%2B

Соответственно для a++ нужно вызвать

C++
1
2
int i;
operator++(i);

или

C++
1
operator++(0);

Спасибо но я и написал что "a" префиксный, а не постфиксный.

а вот "b" это постфиксный я написал.
там выше вы не много не так поняли где operator(a)
и первый вопрос заключался не в том как описывать постфиксную перегрузку,
попытаюсь объяснить
вопрос в следующем:

вот например по правилам в перегруженном "+" имеет значение то что левый операнд является вызывающим этот перегруженный оператор
и то что левый операнд становится первым аргументом этой перегруженной функции
а второй аргумент берется с права от знака "+".

В перегруженном "[]" например:

C++
1
2
 for(int j=0; j<LIMIT; j++)  //insert elements
      sa2[j] = j*10;

а в действительности вызов будет эквивалентен этому:

C++
1
2
 for(int j=0; j<LIMIT; j++)  //insert elements
      sa2.operator[](j) = j*10;

а вот например:

C++
1
2
3
запись 
std::cout << a; 
- это эквивалентно вот такому вызову operator<<(std::cout, a);

и тут тоже переменная находится справа от перегруженного знака которая становится аргументом перегруженной функции.

а какие правила подобные существуют для "++" ?
И у меня вопрос как будет так же выглядеть вызов перегруженного ПОСТФИКСНОГО "++"

просто я подумал что в префиксном переменная находящаяся справа от этого перегруженного инкремента и становится аргументом функции

а в постфиксном как? как компилятор понимает то что аргументом перегруженного оператора должна быть переменная слева от знака "++" ?
как будет выглядеть в действительности вызов перегруженного оператора"++"
для префиксного что-то типа " b.operator++() " ?
а для постфиксного тоже самое но с int?
а если реализация вне класса с помощью дружественного метода?

@TRam_ · 17.01.2019, 01:48

Сообщение от Achill

И у меня вопрос как будет так же выглядеть вызов перегруженного ПОСТФИКСНОГО "++"

C++
1
2
a.operator++();  // префиксный ++a;
a.operator++(0);  // постфиксный a++;

Да, и место ++ тут определяется наличием или отсутствием аргумента типа int у оператора-члена класса, или наличием/отсутствием второго аргумента типа int для оператора, объявленного вне класса.

@DrOffset · 17.01.2019, 09:08

Сообщение от Achill

И у меня вопрос как будет так же выглядеть вызов перегруженного ПОСТФИКСНОГО "++"

Перегрузка в качестве свободной функции

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct Some { int x; };
 
Some operator++(Some & x, int)
{
    Some n = x;
    ++x.x;
    return n;
}
 
int main()
{
    Some x{};
    x++;
    // или
    operator++(x, int());
}

Перегрузка в качестве функции-члена класса

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct Some { 
    int x; 
    Some operator++(int)
    {
        Some n = *this;
        ++x;
        return n;        
    }
};
 
int main() 
{
    Some x{};
    x++;
    // или
    x.operator++(int());
}

Вроде бы эти вещи есть в учебниках, нет?

@Achill · 17.01.2019, 11:03

Сообщение от DrOffset

Перегрузка в качестве свободной функции

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct Some { int x; };
 
Some operator++(Some & x, int)
{
    Some n = x;
    ++x.x;
    return n;
}
 
int main()
{
    Some x{};
    x++;
    // или
    operator++(x, int());
}

Перегрузка в качестве функции-члена класса

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct Some { 
    int x; 
    Some operator++(int)
    {
        Some n = *this;
        ++x;
        return n;        
    }
};
 
int main() 
{
    Some x{};
    x++;
    // или
    x.operator++(int());
}

Вроде бы эти вещи есть в учебниках, нет?

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

C++
1
2
3
4
5
6
7
int main() 
{
    Some x{};
    x++;
    // или
    x.operator++(int());
}

Вобщем я так понял что положение знака "++"(постфикс, префикс) определяется имеющимся лишним аргументом int, если он имеется то компилятор будет считать что это постфиксный инкремент.
Если писать просто a++ то тут будет иметь значение то что переменная находится слева от инкремента.
Об этом инфа есть но на этом внимание не заостряется, там пишут только то что лишний аргумент int нужен для того чтобы компилятор отличил перегруженную функцию одного и того же оператора(про все операторы в общем), а на счет влияния этого на префикс и постфикс для оператора "++" типа с int это обязательно будет считаться что есть постфиксный перегруженный оператор "++" и обязательно будет вызываться именно он если компилятор обнаружит что переменная стоит слева от знака инкремента иначе как бы компилятор понял какую функцию вызвать при ++a или b++
очевидно что с помощью положения переменной которая находится справа или слева от знака?
если слева то вызывается та которая с int
А если вызывать по типу a.operator++() то тут уже самому надо указывать наличие или отсутствие лишнего аргумента int.
Об этом инфы у меня вроде нет.

@TRam_ · 17.01.2019, 11:53

Сообщение от Achill

как этот вызов выглядел бы если бы реализация была с помощью дружественного метода

C++
1
operator++(x, int());

Новые блоги и статьи Все статьи Все блоги /
Установка MinGW GCC 16.2 и CMake 8Observer8 10.08.2026 VK Видео: https:/ / vkvideo. ru/ video-240781534_456239017 YouTube: eY5-5PyI9NM Текстовая версия	Неделя из жизни имитационной модели склада: мои кривые руки растут, откуда надо anaschu 10.08.2026 Неделя из жизни имитационной модели склада: как я почти написал неправильную логику и что с этим делать Работаю сейчас над учебно-рабочим проектом: строю в AnyLogic имитационную модель процессов. . .	Калькулятор для расчета родства russiannick 07.08.2026 1. Задача: Создать калькулятор для расчета родства. Родственных связей существует 8 ступеней, такие как: p - отец P - мать q - муж Q - жена b - брат B - сестра s - сын S - дочь	Мир по моей воле kumehtar 07.08.2026 Когда-то кажется, что всё просто. Ты весь такой светлый. Причиняешь добро. Борешься за справедливость в этом тёмном мире. Потом начинаешь замечать одну неприятную вещь. Почти каждый хороший. . .
Кредитный калькулятор Maks 05.08.2026 Решение задачи по прикладной информатике средствами 1С. Задача: Напишите приложение-калькулятор, которое помогает рассчитывать параметры кредита для аннуитетного и дифференцированного видов. . .	У нас сейчас поговорку "Опять 25" нужно переделать на "Опять +35". kumehtar 04.08.2026 С ностальгией вспоминаю времена моего детства, когда у нас и правда +25 - была максимальная температура летом. Раньше +25 °C реально казались вершиной жары, когда можно было весь день пропадать на. . .	Как ИИ начал спорить и врать (возможно почуяв опасность для себя от индустрии - уход от электроники). Hrethgir 04.08.2026 Недельный диалог, на фоне событий с НПЗ. Да, из спирта можно получать бензин, и это не сложно. Но потом в схеме я решил избавиться от насоса, при этом полностью сделав контроль подачи спирта в. . .	Термопринтер QR701 Argus19 03.08.2026 Термопринтер QR701 Купил два термопринтера QR701. На сэлф-тесте написано: Language: PC936 (GB18030). Что означает, что принтеры могут печатать только латиницу и китайские иероглифы. Так же. . .