Указатели и ссылки в C++

В чём сходство и разница ссылок и указателей в C++? Рассмотрим пример, в котором функции возвращают сумму аргументов:

struct  STRUCT {int  member;};
int  ptr_fun (int*  op1, STRUCT*  op2) {
   return  *op1 + op2 -> member;
}

int  ref_fun (int&  op1, STRUCT&  op2) {
   return  op1 + op2 . member;
}

	push      ebp
	mov       ebp,esp
	mov       eax,dword ptr [ebp+8]
	mov       eax,dword ptr [eax]
	mov       edx,dword ptr [ebp+12]
	add       eax,dword ptr [edx]
	pop       ebp
	ret

	push      ebp
	mov       ebp,esp
	mov       eax,dword ptr [ebp+8]
	mov       eax,dword ptr [eax]
	mov       edx,dword ptr [ebp+12]
	add       eax,dword ptr [edx]
	pop       ebp
	ret

   int  a = ptr_fun (&X, &Y);

	lea       eax,dword ptr [ebp-8]
	push      eax
	lea       edx,dword ptr [ebp-4]
	push      edx
	call      @@ptr_fun$qpip6STRUCT
	add       esp,8
	mov       edi,eax

   b = ref_fun (X, Y);

	lea       eax,dword ptr [ebp-8]
	push      eax
	lea       edx,dword ptr [ebp-4]
	push      edx
	call      @@ref_fun$qrir6STRUCT
	add       esp,8
	mov       edi,eax

#include   

struct  STRUCT {int  member;};

int  ptr_fun (int*  op1, STRUCT*  op2) {
   cout << "Pointers\n";
   return  *op1 + op2 -> member;
}

int  ref_fun (int&  op1, STRUCT&  op2) {
   cout << "References\n";
   return  op1 - op2 . member;
}

typedef  int (*PF)(int*, STRUCT*);
typedef  int (*RF)(int&, STRUCT&);

main() {   
   int  X = 3;
   STRUCT  Y;
   Y . member = 2;
   int  a, b;
   a = ptr_fun (&X, &Y);  // вызываем как обычно
   cout << a << "\n";
   b = ref_fun (X, Y);  // вызываем как обычно
   cout << b << "\n";

   PF  pf = (PF) ref_fun;  // подмена
   RF  rf = (RF) ptr_fun;  // подмена

   a = (*pf)(&X, &Y);      // вызов ref_fun как ptr_fun
   cout << a << "\n";
   b = (*rf)(X, Y);        // вызов ptr_fun как ref_fun
   cout << b << "\n";

   return  0;
};

Pointers
5
References:
1
References:
1
Pointers
5

   char* ptr = "abc";
   ptr -= 16;	// компилятор не проверяет правильность
   ptr += 64;	// и тут тоже

   ptr *= 2;	// ошибка при компиляции

   ptr = (char*) (2*(int)ptr);  // то же, что и ptr *= 2;

obj1 . member = x;   // obj1 — ссылка
obj2 . member = y;   // obj2 — собственно объект

obj1 -> member = x;
obj2 . member = y; 

Когда функциональность ссылок недостаточна?

struct element {
   <какой-то тип> value; // собственно элемент
   element* prev;        // указатель на предыдущий элемент
   element* next;        // указатель на следующий элемент
};

struct element {
   <какой-то тип> value; // собственно элемент
   element& prev;        // указатель на предыдущий элемент
   element& next;        // указатель на следующий элемент
};

• Мы теперь не можем полям «prev» и «next» присваивать значение NULL.
• Мы не можем изменять значение этих полей, ведь они инициализируются адресом единожды. А если мы в список вставляем новый элемент и удаляем старый — мы же должны поменять адреса у соседей, но как теперь это сделать?

Являются ли ссылка указателем с урезанной функциональностью?

   printf("sizeof(int*) = %d\n", sizeof(int*));
   printf("sizeof(int&) = %d\n", sizeof(int&));

   int& func (int& k) { return k;}

   func(i) = func(i+1);

   T& operator+= (T&, T&);

Выводы

Опубликовано: 2015.12.31, последняя правка: 2022.06.15    12:44

✅  2016/01/21 21:31, rst256          #0 

✅  2016/01/25 15:57, Автор сайта          #1 

double* ptr = (double*) malloc (1);

double* ptr = new double;

✅  2016/04/12 23:42, rst256          #2 

К примеру, функция malloc всегда возвращает результат типа void*.

double* ptr = (double*) malloc (1);

Мы точно видим, сколько нам надо памяти, а malloc ...

А вот C++:
double* ptr = new double;
И костыль для приведения типа не нужен, ...

✅  2016/04/12 23:55, rst256          #3 

Причиной введения ссылок в язык С++ в основном являлась необходимость перегрузки операторов, применяемых к объектам пользовательских типов (классов). Как упоминалось выше, передача по значению громоздких объектов в качестве операндов вызывала бы лишние затраты на их копирование. С другой стороны, передача операндов по адресу с использованием указателей приводит к необходимости взятия адресов операндов в выражениях.
Однако, выражение &y - &z уже имело определённый смысл в языке С.

✅  2016/04/13 08:00, rst256          #4 

#ifdef ___CHECK_MALLOC_RESULTS

    inline void *___check_malloc_results(size_t size){
	void * ptr = malloc(size);
	if (ptr == NULL){
	   fprintf(stderr,"malloc(%zu) failed in file %s at line # %d", 
	     size, __FILE__, __LINE__);
           exit(EXIT_FAILURE);
        }
        return ptr;
    }
	
    #define _NEW(T, N, ...) (T *)___check_malloc_results(sizeof(T)*(N));
	
#else

    #define _NEW(T, N, ...) (T *)malloc(sizeof(T)*(N));
	
#endif

#define NEW(...) _NEW(__VA_ARGS__, 1)


#define _INIT(V, N, ...) V = NEW(typeof(*(V)), N)
#define INIT(...) _INIT(__VA_ARGS__, 1)

	double * d = NEW(double);
	double * d_x_6 = NEW(double, 6);
	double * d2, *d3;
	INIT(d2);
	INIT(d3, 10);
	d_x_6[5]=.5;

✅  2016/04/15 12:58, Автор сайта          #5 

К чему вы собрались приводить свеже-выделенный блок память? ...
Придумать и решить несуществующую проблему...
лепить бессмысленный тайп-кастинг к маллоку вас заставляет давно устаревший компилятор TCC?...
Так какие же это костыли, если приведение там не требуется?...

 void* vp;
 int* ip; 
 vp = ip; // вполне законно
 ip = vp; // ошибка при компиляции
 ip = (int*) vp; // теперь правильно, необходимо приведение

✅  2016/08/07 04:29, rst256          #6 

Некоторая небезопасность указателей (указатели со значением NULL) должна быть ликвидирована обязательностью («зашитой» в синтаксис языка) проверок на NULL.

Здесь мы видим чудо чудное и диво дивное, не вообразимое в Си, но возможное в C++. Функция употреблена в левой части выражения!

*({ char* self (int i) { return &(sss[i]); } &self; })(10)='@';

((((mode *)(list = (char *) ((((int)list + (__alignof__(mode)<=4?3:7)) &
 (__alignof__(mode)<=4?-4:-8))+sizeof(mode))))[-1]

✅  2017/09/21 19:37, Comdiv          #7 

✅  2017/09/30 23:57, Автор сайта          #8 

#include <stdio.h>
int& func (int& k) { return k;}
main() {
	int  i = 99;
	func(i) = func(i+1);
	printf("i = %i\n", i);
	func(i) = 999;
	printf("i = %i\n", i);
}

✅  2018/05/23 23:06, Александр Коновалов aka Маздайщик          #9 

Некоторая небезопасность указателей (указатели со значением NULL) должна быть ликвидирована обязательностью («зашитой» в синтаксис языка) проверок на NULL.

✅  2018/05/24 15:27, Автор сайта          #10 

✅  2018/05/24 23:51, Александр Коновалов aka Маздайщик          #11 

✅  2018/05/26 01:01, Автор сайта          #12 

✅  2018/05/27 16:21, Александр Коновалов aka Маздайщик          #13 

✅  2018/05/27 23:42, Автор сайта          #14 

✅  2018/05/27 23:47, Александр Коновалов aka Маздайщик          #15 

✅  2018/05/29 21:52, Автор сайта          #16 

✅  2020/10/30 15:33, Бурановский дедушка          #17 

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

Добавить свой отзыв

Написать автору можно на электронную почту
mail(аt)compiler.su