Привет всем. скажите, не компилируя код, ответ на вопрос:

Какое значение примет переменная result1 и result2 после выполнения следующиего фрагмента кода:

int array[10];
int * a = array;
int * b = &array[9];
int result1= b - a;



char array[10];
char* a = array;
char* b = &array[9];
int result2= b - a; 

Это сообщение отредактировал(а) jimbo - 23.4.2010, 13:08

9

второй код не скомпилируется.

первый в принципе тоже.

jimbo, ну будут в обоих случаях ошибки компилятора -
    - (в первом) компилятор не будет знать что такое chararray[10]
    - (в втором) компилятор будет кричать что то типа can't assign value to rvalue: 2 = b - a;

Это сообщение отредактировал(а) SenkraD - 23.4.2010, 12:24

jimbo
а чем отличаются первый и второй код?


почему?

Добавлено через 36 секунд

а...  в таком смысле, ну полагаю это опечатки.

я проперся. виноват.

int array[10];
int *a = array;
int *b = &array[9];
int result1= b - a;



char array[10];
char* a = array;
char* b = &array[9];
int result2 = b - a;

Добавлено через 2 минуты и 38 секунд
Да ребят, опечатки. я просто вручную писал код. да еще и ошибся при копировании. все исправил и ответ дал только  один человек. что у остальных скомпилировать не получилось из за опечаток?)

jimbo, исправленный код компилится нормально.
Ты пишешь второй код вместо первого или вместе с первым. если второе - тогда нормально, что не компилится

jimbo, для любых типов получится 9, т.к. результат приводится к размерности массива.

Ребят, вы вопрос читаете? я ж не спрашиваю ответ, я знаю как программировать. 

Вопрос заключался в том, что разница в адресах в 2-х примерах разная. это видно даже не компилируя! но результат одинаковый. т.е. вот если бы я решал эту задачу на бумаге - я бы сказал что в первом случае это будет 9*sizeof(int), во втором 9*sizeof(char). И я до сих пор уверен в этом. Только почему ответ всегда 9? Компилятор т.е. всегда показывает разницу не между адресами а между элементами массива. Т.е. когда происходит вычетание адресов, разница преобразуется с учетом размерности типа - почему? это же не явно! если бы я писал программу, я бы обязательно делил на размерность инта, чтобы получить индекс в массиве. допустим у нас быбыло:

int array[100];
int * ptr = &array[50];
int ptr2 = func(ptr);
int diff = ptr2-ptr;
int result = array[50+diff/sizeof(int)];

где func - функция каким-либо образом изменяющая адрес.допустим плюс 5 элементов.

а в итоге компилятор бы давал мне diff = 5. и result был бы не тем элементом что я хотел бы увидеть!


КОНСЕРВАТОР, объясни пожалуйста, почему результат автоматом приводится к размерности массива, в следствие чего это происходит?

jimbo, 

переведу Ваши задачи и вопрос по ним с "программного"  на "человеческий": 

Задача 1 :
Сколько арбузов в ряду арбузов между 3м и 10м ?
Задача 2:
Сколько апельсинов в ряду апельсинов между 3м и 10м ?

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

Это адресная арифметика. Сделайте для int-а
(char*)&a[9]-(char*)a
и в разности получите свои волшебные байтики.

Результат операции с адресами - значение уже кратное типу(int, char).

Ок. я как бы понимаю что ответ всегда 9, и что разница между адресами уже приводится к типу. я не совсем понимал, для чего это сделано?

Теперь я понял. Попытаюсь объяснить. это делается автоматически, для удобства программирования видимо.

когда мы используем указатель таким образом:

char* ptr;
char massiv[20];
ptr = massiv[0];
while(*ptr!=0)
{
     ptr++; // т.е. в этом месте мы инкрементируем значение по указателю, в зависимости от типа попадаем на нужный адрес. Вот только тут я вижу надобность текущей адресной арифметики
}

jimbo, такая адресная арифметика сделана для массивов, т.к.
&a[1]
эквивалентно
a+1

Да, я это уже понял. как бы сам и объяснил. просто никто до этого не заикнулся что сделано это из удобства, как и система little endian. PROFIT от такого использования адресов - очевиден, но математически он ни разу не очевиден. 

Это сообщение отредактировал(а) jimbo - 23.4.2010, 19:19