Указатель изменения на массив для получения определенного элемента массива
через прототип с forEach (), который должен пропустить свойства цепи прототипа:
Object.prototype.each = function(f) {
var obj = this
Object.keys(obj).forEach( function(key) {
f( key , obj[key] )
});
}
//print all keys and values
var obj = {a:1,b:2,c:3}
obj.each(function(key,value) { console.log(key + " " + value) });
// a 1
// b 2
// c 3
5 ответов
Несомненно, можно управлять указателем для доступа к различным элементам в массиве, но необходимо будет управлять содержанием указателя (т.е. адрес того, на что p указывает), а не адрес самого указателя.
int *p = new int[3];
p[0] = 13;
p[1] = 54;
p[2] = 42;
cout << *p << ' ' << *(p+1) << ' ' << *(p+2);
Каждое дополнение (или вычитание) означает последующий (предшествующий) элемент в массиве. Если p укажет на 4-байтовую переменную (например, интервал на типичных ПК на 32 бита) в адресе говорят 12345, то p+1 укажет на 12 349, а не 12346. Обратите внимание, что Вы хотите изменить значение того, что p содержит прежде, чем разыменовать его к доступу, на что оно указывает.
Мне нравится делать это:
&p[1]
Мне это выглядит более опрятным.
Не совсем. &p адрес указателя p. &p+1 будет относиться к адресу, который является тем int* далее вперед. То, что Вы хотите сделать,
p=p+1; /* or ++p or p++ */
Теперь, когда Вы делаете
cout << *p;
Вы доберетесь 54. Различие, p содержит адрес запуска массива ints, в то время как &p адрес p. Для перемещения одного объекта вперед необходимо указать далее в международный массив, не далее вдоль стека, который является где p жизни.
Если Вы только имели &p затем необходимо было бы сделать следующее:
int **q = &p; /* q now points to p */
*q = *q+1;
cout << *p;
Это также произведет 54, если я не ошибусь.
Это было некоторое время (много лет), так как я работал с указателями, но я знаю, что, если p указывает в начале массива (т.е. p [0]) и Вы увеличили его (т.е. p ++) затем p будет теперь указывать на p[1].
Я думаю, что необходимо разыменовать p для получения до значения. Вы разыменовываете указатель путем помещения * перед ним.
Так *p = 33 с изменением p [0] к 33.
Я предполагаю, что для получения второго элемента Вы использовали бы * (p+1) так синтаксис, в котором Вы будете нуждаться, был бы:
cout << *(p+1)
или
cout << *(++p)
Думайте о "типах указателей" в C и C++ как установление очень длинной, логической строки ячеек, наложенных на байты в пространстве памяти ЦП, запускающегося на уровне байта 0. Ширина каждой ячейки, в байтах, зависит от "типа" указателя. Каждый тип указателя кладет холмы строка с отличающимися ширинами ячеек. A "int *" указатель устанавливает строку 4-байтовых ячеек, так как ширина устройства хранения данных интервала составляет 4 байта. A "double *" устанавливает 8-байтовую строку на ячейку; a "struct foo *" указатель устанавливает строку с каждой ячейкой ширина сингла "struct foo", независимо от того, что это. "Адрес" любой "вещи" является байтовым смещением, запускающимся в 0, ячейки в строке, содержащей "вещь".
Адресная арифметика с указателями основана на ячейках в строке, не байтах".*(p+10)"ссылка на 10-ю ячейку мимо "p", где размер ячейки определяется типом p. Если тип "p" является "интервалом", адрес "p+10" составляет 40 байтов мимо p; если p является указателем на структуру 1 000 байтов длиной, "p+10" составляет 10 000 байтов мимо p. (Обратите внимание, что компилятор добирается для выбора оптимального размера для структуры, которая может быть больше, чем, что Вы думали бы; это происходит из-за "дополнения" и "выравнивания". 1 000-байтовая обсужденная структура могла бы на самом деле взять 1 024 байта за ячейку, например, таким образом, "p+10" на самом деле составит 10 240 байтов мимо p.)