C++

Ммм. А в С++ нету массивов. есть указатели. можно передать копию std::vecotra, можно создать через new новый, при помощи memcpy скопировать туда данные и это уже передать.

> А в С++ нету массивов
Давно ли?

>Давно ли?

Видимо, речь идёт о старой байке, что якобы массив и указатель — одно и то же.

> Видимо, речь идёт о старой байке, что якобы массив и указатель — одно и то же.

А в чем разница кроме синтаксиса?

> А в чем разница кроме синтаксиса?
int a[10];
int *a;

есть разница? Задай себе вопрос, что ты можешь сделать с "a" в первом и во втором случае.

>А в чем разница кроме синтаксиса?

Читайте факи, они рулез. http://c-faq.com/aryptr/aryptr2.html

создай копию и передай :-\

Если записать так:

int* a = alloca( sizeof( int ) * 10 );

то разницы вроде нет никакой

> А в чем разница кроме синтаксиса?

int *a1;
int a2[10];

sizeof a1; // 4
sizeof a2; // 40

a1 = 0; // ok
a2 = 0; // syntax error

>Как в функцию С++ передать копию масива, а не сам массив?

а как ты передаёшь в функцию массив, расскажи:) А как копию передавать будешь?

>int a[10]; >int *a;

Не, не совсем так

int a[10]; int * const a;

Да, на уровне языка есть такой хак c sizeof(). можно даже считать число элементов sizeof(a)/sizeof(a[0]). а теперь расскажите мне, если массив - полноценный тип данных, как у него обстоят дела с передачей в функцию.

Понятно, спасибо за разъяснение.

Кто в лес, кто по дрова..

>> Видимо, речь идёт о старой байке, что якобы массив и указатель — одно и то же.

>А в чем разница кроме синтаксиса?

Для линкера массив и указатель это разные вещи.

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

можно массив константного размера обернуть в структуру и так передавать:)

boost::array

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

>можно массив константного размера обернуть в структуру и так передавать:)

Костыли то всегда найдутся =) - это просто было доказательство в пользу утверждения что массивов в С нету.

std::array

Да спор-то на самом деле не о том существуют или нет массивы в С, а о том как назвать то что есть :)

>массивов в С нету

Ну бред же. Да, операции копирования нет; но массивы есть, даже многомерные. Более того, как выше показано по ссылке, массив не есть указатель (хотя в некоторых ситуациях поведение похоже).

>>можно массив константного размера обернуть в структуру и так передавать:)

>Костыли то всегда найдутся =) - это просто было доказательство в пользу утверждения что массивов в С нету.

Попробуй написать в .h файле

extern const char* str;

а в .c файле:

const char str[] = "some string";

Линкер не будет думать что это одно и тоже написанное по-разному.

>даже многомерные

o_O когда повявились? Есть указатели на указатель ("массивы" "массивов").

>хотя в некоторых ситуациях поведение похоже

Наоборот, это одно и тоже, но поведение иногда разнится.

Более того, если

int* a = alloca( sizeof( int ) * 10 );

и

int a[10];

еще ведут себя похоже, то вот уже

int **a;

и

int a[10][10];

Уже облом.

> o_O когда повявились? Есть указатели на указатель ("массивы" "массивов").

-1

> Наоборот, это одно и тоже, но поведение иногда разнится.

+1

>>даже многомерные

>o_O когда повявились? Есть указатели на указатель ("массивы" "массивов").

А вот это уже фигня. int a[2][2] - это совсем не int **a.

Насчет копирования: придется его производить достаточно большое кол-во раз(в цикле) поэтому не пойдет. Кроме того, массив двумерный. Поэтому копирование займет много времени. Что-то слышала насчет кастования в константный - может это поможет? Не подскажете, как это? Еще одно: насколько поняла, если кастовать с помощью стандартных операторов типа static_cast, то все равно значения элементов массива меняются.

>Как передаётся в функцию массив:
естессно, через указатель на нулевой элемент)что-то типа того:

void f(char **);

может еще что-то вроде const char** использовать? а внутри функции снимать константность - это возможно? Просто тогда косяки с вызовом выходят - нельзя будет передать в качестве аргумента неконстантый массив. А после выхода из функции в этом случае в основной программе не окажется ИЗМЕНЕННЫЙ массив?? А надо бы, чтоб был такой, как ДО передачи в функцию f.
ЗЫ спасибо всем, кто откликнулся=)

>o_O когда повявились?

Всё с вами ясно. Марш читать K&R.

>Наоборот, это одно и тоже, но поведение иногда разнится.

Ох уж это желание пустить реки вспять. Есть устоявшаяся терминология, то что она тебе не нравится мало кого волнует; массивы от этого массивами быть не перестанут.

гкхм... а на МОЙ ВОПРОС ответ в этом форуме найдется или будем беседовать на тему формальной логики - что такое массив?

>o_O когда повявились? Есть указатели на указатель ("массивы" "массивов").

int a[x][y] - это на самом деле одномерный массив и никакой не указатель на указатель. Просто элементы адресуются не так, как в "обычном" одномерном (при компиляции по x и y вычисляется реальное смещение; аналагочно с и N-мерными массивами).

> Насчет копирования: придется его производить достаточно большое кол-во раз(в цикле) поэтому не пойдет.

Ну тогда придется функции ничего не передавать. Зачем ей этот массив? Пусть без него работает.

>гкхм... а на МОЙ ВОПРОС ответ в этом форуме найдется или будем беседовать на тему формальной логики - что такое массив?

Да, делать memcpy перед вызовом функции. Или прямо в ней (если такое поведение нужно всегда). Или пользоваться c++-векторами (std, boost, etc., самописный).

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

если вам нужно создавать локальную копию для работы внутри функции для массивов небольшого размера то calloc + memcpy внутри функции. кстати, скажите "много" это сколько? 1E6?

>это на самом деле одномерный массив и никакой не указатель на указатель.

Я говорю не о том, как это в памяти, о синтаксисе языка. И с синтаксической точки зрения это именно указатель на указатель:

a[0] - указатель на первый массив, a[0][1] - указатель на второй элемент в первом массиве.

Вот в паскале - действительно многомерные массивы: a : array [1..10, 1..10] of integer

на строчку a[0] выдаст ошибку. ибо это не массив массиовов. Нужно a[0,1]

>И с синтаксической точки зрения это именно указатель на указатель: 

Что значит с синтаксической точки зрения? Забей на синтаксис. То, что синтаксис совпадает еще ничего не значит. a[10][10] - это как-бы массив массивов, а не указатель на указатели-с. 

#include <stdio.h>
int f(int** a){
    return a[1][1];
}

int main(){
    int a[10][10];
    a[1][1] = 100;
    printf("%d", f(a));
}


Вот такой вот код работать не будет.

>Я говорю не о том, как это в памяти, о синтаксисе языка. И с синтаксической точки зрения это именно указатель на указатель:

Да плевать на синтаксис как таковой. Важно же понимать, что за ним лежит. Ваше непонимаие привело к фэйлу:

>a[0] - указатель на первый массив

Фиг там. Это адрес всего массива. Если быть дотошным, то адрес первого элемент массива. А вот a[1] - адрес "второго", и "третьего", и ..., и "N" массивов.

>a[0][1] - указатель на второй элемент в первом массиве

А это вообще не указатель, а значение (которое *(a+1*sizeof(sometype))).

> если вам нужно создавать локальную копию для работы внутри функции для массивов небольшого размера то calloc + memcpy внутри функции. кстати, скажите "много" это сколько? 1E6?

Только вместо memcpy лучше использовать std::uninitialized_copy, и перед выходом из функции std::destroy.

А еще лучше использовать std::tr1::array или std::vector:
#include <tr1/array>
//#include <vector>

#include <cstdio>

template <typename T, size_t N>
void func(T (&arg)[N]) {
	typedef std::tr1::array<T, N> hack;
	hack copy = reinterpret_cast<hack&>(arg); // в теории может где-то не работать :) но по-идее должно
	// или std::vector<T> copy(arg, arg+N);
	copy[0] = 0xBAD;
}

int main() {
	int array[100];
	for (int i=0; i<100; ++i)
		array[0] = 0xC0073;
	func(array);
	std::printf("0x%x\n", array[0]);
}

>o_O когда повявились? Есть указатели на указатель ("массивы" "массивов").

товарищь, вы некомпетентны. Если это одно и тоже попробуйте сделать:

int a[2][2] = {{1, 2}, {3, 4}} int **b = (int**)a;

и обратитесь к елементу b[1][1]. Ну как, видите 4? ;-)

[off]а что это за зверь такой, std::uninitialized_copy?[/off]

int a[2][2] - это массив массивов

int **a - это указатель на указатель

массив массивов адресовать нужно скорее так: int *(b[2])

> http://www.sgi.com/tech/stl/uninitialized_copy.html

что-то наподобие
Object source[100500];
Object* dest = (Object*) malloc(sizeof(Object[100500]))
for (int i=0; i<100500; ++i)
    new (dest + i) Object(source[i]);

http://www.sgi.com/tech/stl/uninitialized_copy.html

> int a[10];
> int *a;
> есть разница? Задай себе вопрос, что ты можешь сделать с "a" в первом и во втором случае.

сделать? (SIC!) сделать с ними я могу ровно одинаково. разницы практически нет.

// wbr

sizeof будет разный ))

> sizeof будет разный ))

право, какие мелочи..

// wbr

ну еще мы не сможем a[10] использовать для обращение к произвольному адрессу памяти )

> сделать? (SIC!) сделать с ними я могу ровно одинаково. разницы практически нет.

Лолшто?

int a[10];
int *b;

b = NULL;
a = NULL;

>Лолшто?

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

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

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

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

int * const array=malloc(4*sizeof(int));
array[3]=999;//в роли массива, не?
free(array);