если можно , то проще

массив это не указатель.

Вот что говорит компилятор:

main.cpp:8:6: error: array type 'int [2]' is not assignable
array=array1;
~~~~~^
main.cpp:9:7: error: array type 'int [2]' is not assignable
array1=p;
~~~~~~^

Нельзя массив присваивать, можешь считать, что массив это:

int* const array;

В с++ более строгий тайп чекинг, он любит материться на то, что формально работает, но является UB или подозрительными практиками™.

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

я просто обмениваю указатели значениями. это же не запрещенно в плюсах?

Как уже упомянули - «массив - это не указатель». Ты не можешь присвоить один массив другому таким образом.

Если уж используешь C-шные массивы в C++, то делай это хотя бы так:

#include <string.h>
#include <iostream>

int main(){
        const int size=2;
        const int memsize=size*sizeof(int);

        int array[size]{1, 3};
        int array1[size]{2, 6};
        int arraytmp[size];

        memcpy(arraytmp, array, memsize);
        memcpy(array, array1, memsize);
        memcpy(array1, arraytmp, memsize);

        for(int i=0; i<size; i++){
                std::cout << array[i] << " ";
        }
        std::cout << std::endl;
        for(int i=0; i<size; i++){
                std::cout << array1[i] << " ";
        }
        std::cout << std::endl;
        return 0;
}

я просто обмениваю указатели значениями. это же не запрещенно в плюсах?

Массив - это не только указатель, но и выделенная на него память. При твоём обмене, если бы он даже сработал - ты не выделяешь памяти на буфер для массива. В результате у тебя затерлось бы всё.

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

с точки зрения синтаксиса языка есть ошибка?

1.cpp: В функции «int main()»:
1.cpp:7:7: ошибка: некорректное присваивание массива
 array=array1;
       ^~~~~~

Звучит как ошибка на мой скромный взгляд

https://stackoverflow.com/questions/4118732/c-array-assign-error-invalid-arra...

так, не понял....

Если хочешь жонглировать указателями - выделяй память на все свои массивы через new/delete и жонглируй сколько угодно. Только следи за утечками

Можно просто присвоить адреса массивов другим обычным указателя и обжонглироваться сколько хочешь. Так все и делают.

так в том то и дело что там как бы без больших вопросов пока.

я хотел создать двумерный массив иным способом.

int main(){

int *array[2];//cоздаю массив указателей
int ar[3]{1, 2, 3}; // обычный массив.
array[0]=ar;
array[1]=ar;


//
посути создал двумерный не динамический массив.

//
но почему я не могу сделать так?
array=ar;
вот что родило эту тему.

return 0;
}

почему я не могу сделать так?

Потому что массив можно только инициализировать, а присваивать ему нельзя

а почему?

Так написали в стандарте дяди.

Потому что это не указатель, предназначенный для записи в него произвольных адресов, очевидно. Ты выделяешь в стеке память на массив и потому в твоём ar может храниться только адрес первого элемента твоего массива.

как же тогда я плучаю «2». std::cout << (*(array[0]+1))

а вот тут пожалуйста подробнее... значит имя массива это не такой указатель, как если бы я вдруг решил сделать так int *array, а потом array=new int [2];// посути же массив создался из обычного указателя. то есть array теперь имя массива, а было обычным указателем, с которым я мог делать вот так array=&a;

Ну давай разберем по операциям тобой написанное.

array[0]

array[0] + 1

*(array[0] + 1)

Нубы на ЛОРе

По сабжу: если говорить об адресной арифметике, ТО адрес массива это адрес его первого элемента. Потом ты можешь аккуратно ходить по массиву с помощью инкремента/декремента.

А вообще http://givi.olnd.ru/kr/05.html читать до Просветления.

Без понимания того, что описано по ссылке я бы тебя к экзамену не допустил.

А вообще тебе бы про ассемблер почитать, чтобы знать какая бывает адресация и как ПК работает с адресами переменных заданного типа.

P.S.

но почему я не могу сделать так? array=ar; вот что родило эту тему

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

В случае int array[n] - ты выделяешь память только для n элементов массива, при этом дополнительно ячейка для адреса условно не выделяется. В случае же int *array и так далее, ты выделяешь сначала память под указатель, а потом ещё дополнительно для самого массива. Точно так же, например, двухмерный массив и массив указателей - это разные структуры, т.к. в первом случае (если мы, например создаём двухмерный массив вида arr[n][m]) создаётся массив размера n * m и всё. А в массиве указателей ты ещё дополнительно выделяешь память для n указателей. Более подробно читай в K&R в главе 5.

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

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

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

тогда почему не могу сделать так? array=ar. ведь array-это указатель на массив, который содержит указатели. то есть он был создан вот так *array[2]; и значит он содержит адрес первого элемента этого массива, то есть указателя. // обратите на это внимание// и теперь я хочу чтобы этим первым указатем был ar. то есть это указатель на первый элемент массива.

что неправильно?

В очередной раз: массив не указатель. Присваивать можно уеазателю, а имя массива не является lvalue-указателем.
В качестве rvalue-указателя на начальный элемент имя массива можно использовать только потому, что в этом случае выполняется автоматическое преобразование из int[n] в int*.

ведь array-это указатель на массив, который содержит указатели

Ннееет. Это не указатель. Это массив указателей. Потому и не можешь. Прислушайся к совету Twissel. У тебя каша с теорией, потому ты и путаешься на практике. А потому нет смысла дальше идти пока ты для себя не усвоишь, что массив != указатель на массив. У них разная механика работы, несмотря на то, что некоторые операции применимы к обеим сущностям. Это заложено в синтаксис языка.

что неправильно?

Для начала элементы в массив копируются поштучно, см. выше.

Т.е. компилятор Си за тебя не посчитает что у тебя массивы одинакового размера и их можно один к одному скопировать в новый двумерный массив.

Ты сам должен ему указать, что куда копируется и как. С/Си++ это тебе не Питон тут многое приходится делать ручками и думать, что ты делаешь.

Если не хочешь читать стандарт, где об этом написано, прочти хотя бы это и это

Уже обсуждался этот вопрос)

error: invalid array assignment

https://habr.com/post/251091/

Редкостное говно.

сейчас я вам объясню, как это на самом деле устроено!
...
Этот принцип («выражение, являющееся переменной — ссылка») — моя выдумка. Т. е. ни в каком учебнике, стандарте и т. д. я этот принцип не видел.

Автор обещает разобрать якобы «тонкие» понятия, а начинает нести полную чушь. Причём даже не скрывает, что это отсебятина.

Я не зря уточнил «если не хочешь читать стандарт». ТС(судя по задаваемым вопросам) явно не читал и вполне возможно и не собирается. А если он хочет набивать шишек сам, то пусть не удивляется что ему будут присылать первые ссылки из гугла, которые он не мог нагуглить сам :-)

TL;DR: саму статью на хабре я не читал и не имею абсолютно никакого понятия о том, насколько она хороша или плоха. А впрочем теперь немного немножко имею - у меня есть один отрицательный отзыв от анонимуса.

https://medium.com/@barryrevzin/value-categories-in-c-17-f56ae54bccbe самое аккуратное и, самое главное, актуальное описание из тех что я знаю

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

ладно, тут жизнь научит.

просьба: еще уточните одну деталь.

пишут, что строка в с++ это массив символов. я пытался взять с нее адрес, как адрес массива, но нифига не вышло. что такое string в плюсах? это явно не массив символов. что же это? string st=«abc»; что это?

Ты вообще какие-то книги по С или С++ читал?

я восспитан на просторах форума. тут мои учителя. а книг я не читал.

снова нет

вот массив символов char st[]=«abcd»; тут я могу и адрес взять.

но string st=«abcd»; явно не массив. почему тогда эту конструкцию так называют?

объясните уже

но сдругой стороны , я могу так string st=«abcd»; std::cout << st[0]

Изучи тему «Указатели и const»

int sloth = 3;
const int *ps = &sloth;      // указатель на const int
int * const finger = &sloth; // const-указатель на int

Массив можно сравнить с const-указателем. Можно изменять значения элементов массива. Но сам указатель нельзя изменить.

Ты хочешь поменять указатели (на массивы, через имена массивов) местами. Это нельзя делать для const-указателей.

Си++шка пытается сесть на два стула, с низкоуровневостью и высокоуровневостью одновременно, чего непонятного.

Попробуй пересесть на чистый Си, разберись для начала с ним и не насилуй плюсы, а они не будут насиловать тебя. Когда будешь понимать как работают примитивные структуры, тогда пойдёшь в няшный кресто-мир со свистоперделками, классами, шаблонами и прочим. А пока у тебя и люди и кони, как говорится. Массив символов - это char * - обычный массив чаров, заканчивающийся нуль-терминатором (последний элемент массива должен быть равен нулю). Так, например, хранятся и литеральные строки (когда ты пишешь в коде какой-то текст в кавычках). А string - это объект соответсвующего класса в плюсах, более безопасный и более удобный в некоторых случаях. Общего с массивом чаров у него только то, что и там и там как правило, собственно строки хранятся.

Это уже сделали тут по несколько раз подряд. Читай теорию.

я правильно понимаю?

int *p; // тут создан указатель.
//как только я его свяжу с именем массива , он станет const указателем/
p=new int [2]// указатель 'p' стал указателем const

так?

прям Маугли цифровых джунглей

Толстый троллинг as is.

нет не так

Нет, здесь обычный указатель. Здесь ты можешь попробовать провернуть свое дело. Поменять местами указатели. Но только надо понимать, что ты делаешь, чтобы не «прострелить себе ногу».

тогда каким медотом этого класса string я считывыю строку как массив? string st=«abcd»; st[0];

Здесь новая тема — Перегрузка операторов в C++.