C ++ указатели и адреса

Question

Я просто играл с указателями в качестве аргументов функций, и я знаю это.

#include <iostream>
using namespace std;
void func(int *a)
{
  *a+=1;
  return;
}

int main()
{
  int a=1;
  cout<<a<<endl;//prints 1
  func(&a);
  cout<<a;//prints 2
  return 0;
}

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

, когда мы вызовите fun c (& a) из основной функции в вышеприведенном случае

// начальный адрес этих 4 байтов (размер типа int) данных передается и в нашей функции (fun c) этот адрес хранится в локальном указателе 'a', и когда мы пишем * (a) наш компилятор знает, что нужно прочитать 4 байта данных, потому что он является целочисленным указателем.

короче, мой вопрос

что именно мы передаем 'fun c', когда мы называем fun c (a) где 'a' - это переменная, которая хранит целочисленное значение и что именно fun c (int & a) означает

#include <iostream>

using namespace std;

void func(int &a)
{
  //cout<<*a;// error 
  a+=1;
  //  cout<<a<<endl;
}

int main()
{
  int a=1;
  cout<<a<<endl;// prints 1 
  func(a);
  cout<<a;// prints 2

  return 0;
}

извините за плохой английский sh

Answer 1

Два случая работают одинаково:

Случай 1: func ожидает некоторый указатель на некоторое направление целого числа (int *a), которое, как вы сказали, является первым байтом sizeof (int) блок байтов в соответствии с ОС. Когда вызывается fun c, вы правильно передали это направление func(&a), поэтому компилятор считает этот вызов чем-то вроде: int p = &a; func(p); в любом случае указатель на это направление фактически является тем, что передается.

Случай 2 : fun c ожидает некоторого направления целого числа (int &a). Когда вызывается fun c, вы только что правильно передали значение func(a), поскольку все компиляторы C ++ поддерживают ссылочные параметры, компилятор внутренне передает направление переданного значения, func (&a). Обратите внимание, что если вы попытаетесь вызвать fun c как func (&a), произойдет ошибка, потому что она будет передана примерно как func (&&a), пока компилятор просто ожидает (&a).

OBS: Мы также можно рассматривать второй случай void func(int &a) как ссылку, которая отличается от указателя с примером:

int a = 10;
int &b = a;
cout<<a; //10 is printed
cout<<b; //10 is printed
b = 20;
cout<<a; //20 is printed
cout<<b; //20 is printed

Изменяете ли вы ссылку на a (т.е. b) или изменяете a напрямую, вы изменяете одно и то же значение, потому что они стоят в одном и том же направлении.

Answer 2

Один из способов чтения указателей и ссылок состоит в том, что во время деклараций «*» можно заменить на «что-то, на что указывает». Итак:

int* a;

Означает, что «a» - это то, что указывает на целое число (т. Е. «A» - указатель).

В других местах кода (не объявлениях), «*» можно заменить на «вещь, на которую указывает». Итак:

*a = 5;

Означает, что «вещь, на которую указывает« а », становится равной 5». Т.е. целое число, на которое указывает точка, теперь равно 5.

В вашем первом блоке кода «a» - это просто целочисленный тип. когда вы пишете fun c (& a);, вы передаете адрес 'a' (то есть имя ячейки памяти, в которой хранится значение 'a') функции. Функция ожидает тип int * (что-то, указывающее на int), и это именно то, что вы ему дали.

В функции 'a' - это просто адрес вашей переменной. Затем функция берет этот адрес и говорит: «увеличивайте значение, на которое указывает« а ».

Во втором блоке кода« а »снова является целочисленным типом. На этот раз, однако, функция ожидает ссылочную переменную (потому что определение функции ожидает int & type.

Таким образом, внутри функции 'a' является исходной переменной, а не копией или указателем на оригинал переменная. Функция говорит «увеличить фактическое целое число, которое было отправлено».

Подробнее