максимальное число элементов в массиве в С?

Ты упорот? Что ты мне доказываешь? Ты мне пытаешься доказать бесполезные в реальной жизни особенности.

& не работает для твоего «массива» только из-за обратной совместимости, как я говорил выше. Чтобы &m[0] и &m давали одинаковый результат, на самом делел &m это не &m, а тупо m.

Твой этот галимый пример говорит лишь о том, что px 0, а в a лежит адрес елемента.

  int p;
  int * px = &p;
  px[0] = 0xC001FACE; /* oops! */
  
  int a[1];
  a[0] = 0xDEADBEEF; /* ok */

Собери это и сравни, потом будешь вонять.

Вообщем, ты давай мне объяснишь - что показывает твой пример? Я не покачто не вижу, да и пример твой говно.

На тебе прогу-пруф:
Выводы:
0x6008b0 0x6008b0 0x6008b8 0x0

Похоже, у Вас конпелятор сбойнул, или процессор перегрелся.

Да шо ви говорите?

поэтому &p != p

не всегда

Да шо ви говорите?

Ничего страшного, бывает: я знаю одного человека, который вообще в паинте скриншоты редактировал после внесения изменений.

Дорогуша, ты говори, не стесняёся, что тебе не так.

поэтому &p != p

не всегда

очевидно, что можно присвоить p = &p, но это особый случай

Я ничего не понял.

Можешь показать на примере 8-и битной адресации что к чему?

на таких мелочях шатлы и падают ;)

ok (пусть &a==0)

ui8 a[maxui8] резервирует нам массив в 255элементов от c индексом от 0 до 255-1.

при желании мы конечно можем обратится к a[255] и «погодать на короля»

т.е раньше как то не замечал что максимальный размер массива при равнобитности (B вовсе поля для случая когда шаг адресса 16битное слово) адрессов и данных не даёт легального(без выхода за границы) способо для заведения массива на всю память(данных)

c индексом от 0 до 255-1

почему до 254, а не до 255?

размер отведённого массива 255 от 0 до 254 индекса

зы. тем и ценен Степанов - ведь шатлы падают.

при условии что унас и 8битная память и 8битный беззнаковыйцелый(наибольший тип)

Теперь дошло. Я бы предложил workaround-ы, но ты их и так знаешь (например, объявить два массива друг за другом в struct).

Короче, си-проблемы :).

тем и ценен Степанов - ведь шатлы падают.

окей, я просмотрю его лекции, а то вдруг ПО для шаттлов заставят писать...

А ты про определение массива m[256]. Не юзай просто «массивы» для неосиляторов - юзай православный char * m; и будет тебе счастье.

не не не

я про естественное в условиях С(факт того , что у Дениса Ритчи дисер? был по матлогике?) , что в случае возврата позиции в массиве как результата работы функции нет нужды в отдельном флаге/нул достаточно возвращать размер массива.

т.е как реально круто по итогу спроектирован С.

т.е писать на С++ я врядли когда буду , но вот модель STL с её итераторами ( а точнее , что «итераторы-сила») это вот важно понимать.

итераторы не всмысле конкретно та или иная реализация а как «координаты-позиции»

т.е как реально круто по итогу спроектирован С.

Мде. Не уверен, что правильно понимаю мутный поток твоего сознания, но «реально круто» спроектирован режим адресации с использованием базового регистра. И к этому Ричи никакого отношения не имеет, при всей своей крутизне.

В сишке не нужны 95% костылей оопговна и прочих, которые нужны из-за ущербности почти всех ЯП, ибо они по определению говно.

Единственное, что в стл"е нормальное - это итераторы, но только из-за того, что это копипаста с Сиуказателей. Молодец.

похоже что 1997 это год рождения

режим адрессации с использование базового (индексного ? или ты про случай использования двух индексов вида const+bp+ir оба ) были вроде на лет десять(15?) раньше обнаружены (или больше) т.е вообще явление индексирование через регистр , а не через переписывание кода на ходу.

нет. просто факт , что (как раз там ссылка на аду) что именно разумней иметь ограничение на размер массива(за ведомо иметь такое число-индекс которое не может быть индексом(т.е вне читать то и по нему можно) ((unsign)-1 ) чем ограничивать(типизоровать) тип индекса.

в сишке

сипипишке быстрофикс

неа.

сам подход библиотеки алгоритмов ( с явно высказаными слабыми(как только возможно) свойствами аргументов) и оптимальной(наиболее выч-пам эффективной) для данного уровня слабости ограничений реализации. и чем более конкретные ожидание тем возможно более имеются алго для прикладника.

и то что стл взлетела на С++ - это ведь С++ повезло.

предыдущие варианты на схеме(а перед вроде и на CL),аде

вроде как не оптимально в код отображались.

указатели это рэндомитераторы - наиболее мощьные и следовательно наиболее требовательные к .

поэтому &p != p и &a == a

&p == p[0] p и a - машинные слова в которых хранится адрес памяти(указатель) в случае массива это указатель на первый элемент массива.

Вам на макфак

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

Обрати внимание на адреса.

все логично, extern же

Ты серьёзно это написал или решил посмотреть на очередной срач?

причем я, бегло просматривая ответы, не понял из чего оно выросло и о чем собственно срач.

ты не в курсе? )))

ты не в курсе?

Как обычно, желание выпендриться и окунуть оппонента в дерьмо берёт верх над всем остальным. А для этого подойдёт любая тема. В данном случае всё выросло из вопроса отличается ли массив от указателя.

все логично, extern же

без разницы вообще

static:

static int a[] = { 10 };
static int *b = a;

    .data
    .align  2
    .type   a, %object
    .size   a, 4
a:
    .word   10
    .align  2
    .type   b, %object
    .size   b, 4
b:
    .word   a

на стеке:

int main() {
    char c[] = "aaaaaaaaaaaaaaaaaaaaaa";
    char *d = "bbbbbbbbbbbbbbbbbbbbbb";
}

    [...]
    .section    .rodata
    .align  2
.LC1:
    .ascii  "bbbbbbbbbbbbbbbbbbbbbb\000"
    .align  2
.LC0:
    .ascii  "aaaaaaaaaaaaaaaaaaaaaa\000"
    [...]
    movw    r3, #:lower16:.LC0
    movt    r3, #:upper16:.LC0
    add r4, r7, #4
    mov r5, r3
    ldmia   r5!, {r0, r1, r2, r3} @
    stmia   r4!, {r0, r1, r2, r3} @
    ldmia   r5, {r0, r1}          @ массив
    str r0, [r4, #0]              @
    add r4, r4, #4                @
    strh    r1, [r4, #0]          @
    add r4, r4, #2                @
    lsr r3, r1, #16               @
    strb    r3, [r4, #0]          @
    movw    r3, #:lower16:.LC1
    movt    r3, #:upper16:.LC1
    str r3, [r7, #0]              @ указатель
    [...]

без оптимизации, конечно

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

смертельный номер - массив нулевой длины. жуткий хак конечно, нестандартно всё.

.text
.global lsl
.type lsl, %function

.global not_so_useless
.type not_so_useless, %object

.align 4
.code 32 

lsl:
	lsl r0, r0, #1
	bx lr
not_so_useless = . - lsl

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/mman.h>

int lsl(int a);
extern int not_so_useless[];

int main() {
	int a = 10;
	int b;
	int (*copy_lsl)(int a);

	copy_lsl = malloc(not_so_useless);

	memcpy(copy_lsl, &lsl, not_so_useless);
	asm volatile("dmb" ::: "memory");

	__clear_cache(copy_lsl, copy_lsl + (int)not_so_useless + 1);

	asm volatile("dsb\n\r isb" ::: "memory");

	b = copy_lsl(a);

	printf("a: %d, b: %d\n", a, b);

}

$ ./test
a: 10, b: 20

для полноты сценария можеш добавить сопутствующие( мне не очевидные :) ) сценарии make/ручного сбора

это асm чего ? :)

всё таки массив у тебя не нулевой длины ибо ты его кодом(ставшего данными :) инициализировал и место у него отведено :)

имхо создание нулевого массива это что то что возвращает адресс(константу) конца секции уже отведённых данных без сдвига этой координаты .( то есть размещение двух структур по одному адрессу)

для полноты сценария можеш добавить сопутствующие( мне не очевидные :) ) сценарии make/ручного сбора

собирал так: gcc test.c test_asm.s -o test -O2

это асm чего ? :)

armv7, тегра2. На x86 такие финты проще сделать, барьеры не нужны и сбрасывать кеш не надо.

всё таки массив у тебя не нулевой длины ибо ты его кодом(ставшего данными :) инициализировал и место у него отведено :)

нет, там символ реально указывает в никуда, т.к. значение символа == размеру lsl(). Если объявить символ в С части например как extern int not_so_useless, то получить значение можно через &, т.е. copy_lsl = malloc(&not_so_useless); и т.д.

обычной переменной как-то так сделать можно:

.text
.global lsl
.type lsl, %function

.global sizeof_lsl
.type sizeof_lsl, %object

.align 4
.code 32 

lsl:
	lsl r0, r0, #1
	bx lr
not_so_useless = . - lsl

.data
sizeof_lsl:
.long not_so_useless

вроде взрослый уже, волосы на ногах растут... :)

Зачет

Во что вы превращаете мой девелопмент, сволочи? mono, умаляю, запилите фак.

Все факи давно перенесены в Wiki, соответственно, Сишный фак тоже нужно в Wiki пилить.

С твоим посылом я согласен.

Они видимо никуда не ходят, кроме /forum/*, может прикрепить тему «FAQ по всему: прочитай или забанься» со всеми ссылками на вики? Я даже готов поучаствовать в свободное время и побанить, если права дадите.

как я говорил выше

А кто ты такой, что мы должны верить одному лишь твоему слову?

Что значит только из совместимости? А чему еще &m может быть равно, если определено как int m[1] ? Где в памяти хранится адрес &m? можем ли мы поменять его как это можно сделать с указаотелем.

int buf[2], *p=buf;
++p;
p[-1]

в a лежит адрес елемента

Если что в a и лежит, то уж точно не адрес элемента. Посмотри на ассемблерный листинг, где там говорится о том, что в a лежит адрес элемента?

вот смотри, параметр malloc имеет тип size_t. Предположим, что

unsigned char *x=malloc(MAX_SIZE_T)

С кем ты разговариваешь? С тем, кто не может мыслить (для его понимания недоступны абстракция, обобщение, анализ и синтез) и гордится этим? Зачем?

И где находится это машинное слово a?

&p ==p[0]

Совсем фигню написал.

Ну теперь, когда я высрался, вернемся к сабжу. То, что так поразило ТС, будь он неладен, есть простое следствие того, что в переменной целочисленного беззнакового типа нельзя хранить значение числа равного количеству возможных значений этой переменной. Что в свою очередь является частным случаем более общего урверждения: мощьность множества целых чисел от 0 до N не принадлежит этому множеству, что если записать формально и посчитать ммощность такого множества, становится очевидным.

Т.е. весь этот срач начался с утверждения, которое является следствием тривиального факта: N+1>N.

факт что индекс от 0 ..maxsize-1 тривиален

как и куча других тривиальностей ( что бы из палки получить n частей нужно n-1 отпила ( тут не про оптимизацию позволяющую пилить за раз несколько))

что важно в этой тривиальности - что образование не может охватить все тривиальности и следовательно имеем , что имеем.

Ну вот, выспался и писать лучше стал.

образование не может охватить все тривиальности

Ну так и не надо охватывать все — надо охватывать базу и развивать способность из этой базы получать остальное.

об том и речь

Собери - посмотри, что ты этих хотел сказать, кроме балабольства я не понял.

    char m[1];
    char * p1 = m;
    char * p2 = &m;

Реально? Сходи в школу а, я уже писал про это, да и что ты этим мне хотел сказать? Знал бы ты матчасть, ты бы такую херню не порол.