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

Какое значение примет переменная 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

профит тут только для случая массивов.
для всех остальных случаев - одни неудобства, т.к. надо приводить к (char*) чтобы использовать нормальную адресную арифметику.

в задаче с арбузами и апельсинами то же не очевидно ?

в задаче с арбузами и апельсинами то же не очевидно ?

Нет, не очевидно. мы же спрашиваем не количество апельсинов или арбузов между 1 и 10, а расстояние, скажем в метрах. т.е. если апельсин в 4 раза Уже чем арбуз - то какое расстояние между 1 и 10?

Добавлено через 11 минут и 10 секунд



можно изъезженный примерчик? с утра плохо соображается:(

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

jimbo, пример - это когда надо обходить не массив, а структуру с полями разной длины

Для расстояний используйте диаметры фруктов/ягод - 

   ребят, вопрос уже давным давно не сюда. вы как бы читаете вообще что я пишу?




вот это то и обсуждается! что расстояние для разных типов разное, но из-за адресной арифметики, мы получаем расстояние в нужных нам диаметрах. Вы что, действительно не понимаете суть вопроса? Рассмотрите задачу с точки зрения математики а не программирования. если адрес первого элемента 1000, а десятого - 1036. Вычитая из адреса 10 элемента адрес 1 элемента, мы, математически, получаем 36. это и было в коде result = b - a. никакие преведения к типу тут не стоят. компилятор, изначально, видит, что вычисляется разница между адресами указателей типа int, размерностью 4 байта, приводит разницу в число, кратное размерности, и это, блин, очень логично с точки зрения программирования, но не очевидно с точки зрения математики. вы же не получаете 9 если вычтете из 100-10? а вот в программировании получите, если размерность указателя будет 10 байт. И это очень даже хорошо, для пробега по любому виду массивов. 
char *c_ptr;
int* i_ptr;
struct item *si_ptr;
c_ptr = c_ptr+1;
i_ptr = i_ptr +1;
si_ptr = si_ptr + 1; 
везде эта единичка не одинакова. по сути она равна 1*sizeof(char), 1*sizeof(int), 1*sizeof(struct item)
Видите математическое несоответствие?




в смысле? 


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

ptr [ 100* sizeof(struct tmp)+4] = (double)0.1; разве нет?

jimbo, 
я имел ввиду структуры вида

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

Если вы еще не заметили, адресная арифметика - программерская забава:). Хотите заниматься математикой - вычитайте инты, а адреса оставьте в покое.

В программировании удобно как раз так, как сделано. Я прибавляю или вычитаю что-то из адреса и не парюсь о размерности типов. Хотите низкоуровневых трахов, так работайте с байтовыми буферами.

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

Смысл программы на языке программирования определяется языком програмирования, а не математикой.
В математике x=x+1 невозможно, а в програмировании - на каждом шагу   Вот такой вот парадокс   

Понятия адреса и указателя не эквивалентны, отсюда и непонятки. Арифметика указателей не то же самое, что адресная арифметика (такой в срр вроде как и нет вообще). Во так я вижу данный вопрос.

Взглянув на арбузы и апельсины, встречная задача: допустим (как говорят математики) что для хранения объектов есть некая коробка-контейнер, способная вместить 10 апельсинов или 2 арбуза. Вопрос - в чём измерять, вместимость контейнера?    Получается, что если указатель имеет тип указателя на арбуз, то, очевидно, что в данном случае ответ будет 2, а если тип указатель на апельсин - то 10. А если приведём тип к указателю на вишню, то вообще ого-го. Всё очень даже логично и правильно и с точки зрения математики и с точки зрения программирования   .