Форум программистов [Powered by Invision Power Board]

Версия для печати темы
Нажмите сюда для просмотра этой темы в оригинальном формате

Форум программистов > C/C++: Для новичков > [FAQ] Динамические массивы

Автор: bsa 26.12.2007, 22:07

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

Динамические массивы в Си

Массив - это набор однотипных данных, доступ к которым может быть осуществлен по индексу, т.е. по номеру элемента. В Си принято нумеровать элементы с нуля, поэтому первый элемент всегда имеет индекс 0, а последний - (N-1), где N - это размер массива (количество элементов).
Встроенные средства языка программирования Си позволяют создавать статические массивы - массивы, число элементов которых задается на этапе компиляции и в процессе работы программы не меняется. Но как только сложность задач выходит за банальное "Hello, world!", возникает необходимость менять размеры массива в процессе работы программы...
Что представляет собой массив на уровне ЭВМ? Это непрерывный кусок памяти, в который помещаются все элементы массива. Таким образом, для изменения количества элементов в массиве нужно менять размер этого куска. Но для начала его нужно выделить...
Последняя версия стандарта языка Си позволяет создавать автоматические динамические массивы. Они существуют только в пределах текущей области видимости и при выходе из нее уничтожаются. Синтаксис записи аналогичен статическим массивам, только в качестве указателя размера выступает не числовая константа, а переменная:

Код

#include <stdio.h>

int main()
{
    printf("Input size: ");
    fflush(0);
    int n;
    scanf("%d", &n); //вводим число элементов массива
    int array[n];      //выделяется память под n элементов
    int i;
    for(i = 0; i < n; ++i)
        array[i] = i; //присваиваем им значения
    for(i = 0; i < n; ++i)
        printf("%d\n", array[i]); //выводим их значения
    printf("size = %d\n", sizeof(array)/sizeof(*array)); //убеждаемся, 
          //что sizeof работает так же, как и со статическими массивами
    return 0; //память освобождается автоматически
} //при выходе из области видимости

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

Стандартная библиотека Си предоставляет средства для работы с динамической памятью, такие как:
http://www.cplusplus.com/reference/clibrary/cstdlib/malloc.html, http://www.cplusplus.com/reference/clibrary/cstdlib/calloc.html - выделение памяти
http://www.cplusplus.com/reference/clibrary/cstdlib/free.html - освобождение памяти
http://www.cplusplus.com/reference/clibrary/cstdlib/realloc.html - изменение размера выделенной области памяти (может замещать собой и malloc, и free)
Для их использования надо подключить заголовочный файл http://www.cplusplus.com/reference/clibrary/cstdlib/:

Код

#include <stdlib.h>

malloc() производит выделение памяти, объем которой в байтах указывается в качестве параметра:

Код

void *p = malloc(1024); //выделение 1024 байт памяти

Выделенная таким образом память содержит "мусор" (случайные значения), поэтому перед использованием требуется ее инициализировать.
Функция calloc() производит выделение памяти под набор элементов одинакого размера и его зануление. Первым параметром указывается количество необходимых элементов, а вторым размер элемента в байтах:

Код

int *p = (int*)calloc(256, sizeof(*p)); //выделение памяти под 256 элементов типа int
//это эквивалентно записи
int *p = (int*)malloc(256*sizeof(*p)); //выделение области памяти под 256 элементов типа int
memset(p, 0, sizeof(*p)*256); //обнуление выделенной области

Стоит обратить внимание на использование конструкции sizeof(*p) вместо sizeof(int) или просто числа 4 в качестве размера элемента массива. Эта конструкция, во-первых, позволяет обеспечить платформонезависимость кода (например, на 32-х разрядных машинах размер long равен 4 байтам, а на 64-х разрядных Unix машинах - 8 байт), во-вторых, позволяет уменьшить количество правок кода в случае изменения типа элементов (например, int заменить на double).
Функция realloc() позволяет изменять размер области памяти, которая выделена функциями realloc(), malloc() или calloc() (на самом деле, она еще может выделять память, как malloc, и освобождать, как free):

Код

int *p = (int*)calloc(10, sizeof(*p)); //выделение памяти под 10 элементов типа int
p = (int*)realloc(p, 100*sizeof(*p)); //расширение выделенной области памяти под 100 элементов типа int
free(p); //освобождение выделенной памяти
//-----------------------------------------------------
//этот с виду простой код можно заменить следующим (необходимо только подключить #include <string.h>)
//-----------------------------------------------------
int *p = (int*)calloc(10, sizeof(*p)); //выделение памяти под 10 элементов типа int
//на самом деле реализация функции realloc() несколько сложней
int *t = (int*)calloc(100, sizeof(*p)); //выделение памяти под 100 элементов типа int
memcpy(t, p, 10*sizeof(*p)); //копирование содержимого предыдущего массива в новый
free(p); //освобождение памяти от предыдущего массива
p = t; //присвоение p указателя на новый массив

free(p); //освобождение памяти

Как нетрудно заметить, использование realloc() значительно сокращает код и увеличивает его читабельность. Поэтому ее очень удобно использовать для массивов, размер которых меняется в процессе работы программы.
Вот пример использования динамического массива:

Код

#include <stdlib.h>
#include <stdio.h>
int main()
{
    int i;    //счетчик цикла
    int n;    //в эту переменную будет введено количество элементов в массиве
    int *p;    //в эту переменную будет помещен указатель на динамический массив
    printf("Input number of elements: ");
    fflush(NULL);        //эта функция сбрасывает файловые буфера
    scanf("%d", &n);    //вводим число в переменную n
    p = (int*)malloc( n*sizeof(*p) );
    //можно это сделать так:
    for(i = 0; i < n; ++i)
        p[i] = i*10;    //присваиваем элементам массива удесятеренное значение индекса
    for(i = 0; i < n; ++i)
        printf("%d ", p[i]);    //выводим все элементы массива через пробел в одну строчку
    printf("\n");
    free(p);    //освобождаем память, выделенную под массив
    return 0; //успешное завершение программы
}

В данном примере был создан массив из n элементов типа int, причем число n вводилось с клавиатуры. Указатель на начало массива был присвоен переменной p. Дальнешие операции над p ничем не отличаются от оных для статических массивов. Разве что, sizeof(p) вернет размер указателя p, а не размер массива в байтах.
Как нетрудно заметить, в конце функции идет освобождение памяти, выделенной под массив. Чтобы избежать утечек памяти, нужно всегда освобождать память, как только она перестала быть нужной.
Динамические массивы нельзя копировать путем присваивания указателей:

Код

int *p = (int*)malloc(sizeof(*p)*10);
int *t = (int*)malloc(sizeof(*t)*10);
....
p = t; //возможно, логическая ошибка

Хотя результат и будет похож на требуемый, но изменение массива, на который ссылается указатель t, приведет и к изменению массива, на который указывает p, так как они теперь указывают на один и тотже массив. Да и освободить память, которая изначально была выделена под массив p, теперь нельзя (если, конечно, значение указателя p не было сохранено предварительно). Чтобы этого не происходило, нужно воспользоваться функцией http://www.cplusplus.com/reference/clibrary/cstring/memcpy.html, которая объявлена в стандартном заголовочном файле http://www.cplusplus.com/reference/clibrary/cstring/:

Код

int *p = (int*)malloc(sizeof(*p)*10);
int *t = (int*)malloc(sizeof(*t)*10);
....
memcpy(p, t, sizeof(*p)*10);

Она скопирует данные из массива t в массив p.
Стоит иметь в виду, что указатели на внутренние элементы динамического массива использовать не очень безопасно. Так как после очередного изменения размера массива они могут стать неверны, что приведет к возникновению трудно отслеживаемых ошибок. Указатели на внутренние элементы стоит применять только там, где не предполагается изменений размеров массива.

Создать полностью динамический многомерный массив стандартными средствами языка Си невозможно (как создать частично динамический массив будет сказано ниже). Но можно сымитировать одним из двух способов:
1. через массив массивов
2. через одномерный массив

Рассмотрим первый вариант реализации многомерных динамических массивов на примере двумерного.
Для этого создадим указатель на указатель на, например, int:

Код

int* *p; //это указатель на указатель на int
int i, n, m;
//вводим n и m с клавиатуры
...
//выделяем память под массив указателей
p = (int **)calloc(n, sizeof(*p)); //p теперь указывает на массив указателей на int
//выделяем память для каждой строки массива
for(i = 0; i < n; ++i)
   p[i] = (int*)calloc(m, sizeof(*p[i]));
//теперь можно получить доступ к каждому элементу двумерного массива: p[i][j], где 0 <= i < n, 0 <= j < m
...
//после завершения работы с массивом, необходимо освободить всю выделенную память
for(i = 0; i < n; ++i)
   free(p[i]);
free(p);

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

Код

int *p;
int i, n, m;
//вводим n и m с клавиатуры
...
//выделяем память под массив указателей
p = (int *)calloc(n, sizeof(*p)*m);
//теперь можно получить доступ к каждому элементу двумерного массива: p[i*m + j], где 0 <= i < n, 0 <= j < m
...
//после завершения работы с массивом, необходимо освободить память
free(p);

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

Код

int *p;
int **r;
int i, n, m;
//вводим n и m с клавиатуры
...
//выделяем память под массив указателей
p = (int *)calloc(n, sizeof(*p)*m);
r = (int**)calloc(n, sizeof(*r));
for(i = 0; i < n; ++i)
    r[i] = p + i*m;
//теперь можно получить доступ к каждому элементу двумерного массива: r[i][j], где 0 <= i < n, 0 <= j < m
...
//после завершения работы с массивом, необходимо освободить память
free(r);
free(p);

В данном случае создается массив индексов строк, на который ссылается указатель r. Данный способ имеет по одному преимуществу, по сравнению с двумя предыдущими: во-первых, скорость доступа к каждому элементу такая же, как и в первом способе, во-вторых, скорость создания/удаления массива несколько медленней, чем во втором способе, но выше, чем в первом. Хотя, стоит иметь в виду, что в случае изменения размеров массива необходимо пересчитывать индексный массив.

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

Код

int (*pArray)[10]; // круглые скобки обязательны

Это указатель на массив int, состоящий из 10 столбцов. Из него можно создать двумерный массив с изменяемым числом строк. Или:

Код

double (*pArray)[5][10];

Это уже указатель на двумерный массив double, из которого можно получить трехмерный массив с изменяемым количеством "плоскостей" (трехмерный массив можно представить в виде параллелепипеда (пирог "Наполеон"): pArray[z][y][x], где z - это изменяемая глубина, y - постоянная высота, x - постоянная ширина). В данном случае под "плоскостью" понимается двумерный массив постоянных размеров.
После определения указателя нужно выделить под массив память (далее для простоты рассматривается двумерный массив):

Код

int (*pArray)[10];
pArray = ( int(*)[10] )calloc( 50, sizeof(*pArray) );

В данном случае памяти было выделено на 50 строк. Так как память выделяется непрерывным куском и компилятор языка Си не осуществляет проверки выхода за границы массива, то этот прием позволяет получить доступ ко всем строкам массива так, как это делается в статических массивах:

Код

#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>

int main()
{
        int rowCount = 0;
        int i,j;
        int (*p)[10];
        scanf("%d", &rowCount);
        if (rowCount <= 0)
             rowCount = 1; //нельзя выделить память под менее, чем одну строку
        p = (int (*)[10])calloc( rowCount, sizeof(*p) );
        for(i = 0; i < rowCount; ++i)
                for(j = 0; j < 10; ++j)
                        p[i][j] = i * 10 + j;
        for(i = 0; i < rowCount; ++i) {
                for(j = 0; j < 10; ++j)
                        printf("%3d ", p[i][j]);
                printf("\n");
        }
        free(p);
        return 0;
}

---------------------------------------------------------------------------------------------------------------------
Динамические массивы в Си++

Массив - это набор однотипных данных, доступ к которым может быть осуществлен по индексу, т.е. по номеру элемента. В Си++, так же как и вв Си, принято нумеровать элементы с нуля, поэтому первый элемент всегда имеет индекс 0, а последний - (N-1), где N - это размер массива (количество элементов).
Средства языка программирования Си++ позволяют создавать статические массивы - массивы, число элементов которых задается на этапе компиляции и в процессе работы программы не меняется. Но как только сложность задач выходит за банальное "Hello, world!", возникает необходимость менять размеры массива в процессе работы программы...
Что представляет собой массив на уровне ЭВМ? Это непрерывный кусок памяти, в который помещаются все элементы массива. Таким образом, для изменения количества элементов в массиве нужно менять размер области памяти.

В языке С++ есть встроенные средства, для работы с динамической памятью - new[] и delete[], позволяющие выделять память под массивы и освобождать ее. Чтобы выделить память с помощью new нужно указать тип элемента массива после ключевого слова new и их количество в квадратных скобках. Чтобы освободить память, занимаемую выделенным таким образом массивом необходимо вызвать delete[]. В отличие от free(), delete[] может принимать в качестве аргумента и нулевой указатель, в этом случае он ничего не сделает. Пример:

Код

#include <iostream>
int main()
{
    std::cout << "Input number of elements: " << std::flush; //выводим данную строку на экран
    int n;
    std::cin >> n;    //вводим количество элементов массива
    int *p = new int[n];    //выделяем память
    for(int i = 0; i < n; ++i)
        array[i] = i*10;    //присваиваем элементам массива удесятеренное значение индекса
    for(int i = 0; i < n; ++i)
        std::cout << array[i] << " ";    //выводим все элементы массива через пробел в одну строчку
    std::cout << std::endl;
    delete []p;    //освобождаем память
    return 0;
}

Но пользоваться ими не сильно удобно, так как постоянно нужно помнить о необходимости освобождения памяти, да и встроенных функций для изменения размеров массива нет (нужно создать еще один массив необходимой длины, скопировать данные из старого массива, удалить старый массив). Поэтому есть более комфортные средства для работы с динамическими массивами, которые включены в стандартную библиотеку шаблонов (http://www.cplusplus.com/reference/stl/). В частности, шаблон для работы с простейшими массивами называется vector. Для работы с ним требуется подключить специальный модуль:

Код

#include <vector>

После чего в пространстве имен std появится шаблон http://www.cplusplus.com/reference/stl/vector/...
Так как vector это шаблон, то нужно указать тип объекта, которые будут храниться в массиве. Это делается с помощью угловых скобок: std::vector<int>. Вот небольшой пример использования шаблона vector:

Код

#include <vector>
#include <iostream>
int main()
{
    std::cout << "Input number of elements: " << std::flush; //выводим данную строку на экран
    int n;
    std::cin >> n;    //вводим количество элементов массива
    std::vector<int> array(n);    //создаем массив из n элементов.
    //в дальнейшем, для изменения количества элементов можно использоваться array.resize(n)
    for(int i = 0; i < n; ++i)
        array[i] = i*10;    //присваиваем элементам массива удесятеренное значение индекса
    for(std::vector<int>::const_iterator i = array.begin(), end = array.end(); i != end; ++i)
        std::cout << *i << " ";    //выводим все элементы массива через пробел в одну строчку
    std::cout << std::endl;
    return 0;
}

Как нетрудно заметить, не нужно беспокоиться о расчете необходимого объема памяти и ее освобождении. А в остальном все тоже самое, разве что добавился еще один способ последовательного перебора элементов массива - итераторы (это такой вид универсальных "указателей", инкремент/декремент которых приводит к указанию на следующий/предыдущий элемент). Массивы, созданные с использованием шаблона std::vector, можно присваивать друг другу, главное чтобы тип хранимых объектов был одинаковым:

Код

std::vector<int> a;
std::vector<int> b;
...
a = b; //ок

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

Создать полностью динамический многомерный массив стандартными средствами языка Си++ невозможно (как создать частично динамический массив будет сказано ниже). Но можно сымитировать одним из двух способов:
1. через массив массивов
2. через одномерный массив

Рассмотрим первый вариант реализации многомерных динамических массивов на примере двумерного:

Код

typedef std::vector< std::vector<int> > Int2dArray; //так несколько удобней
Int2dArray array(n, Int2dArray::value_type(m)); //Int2dArray::value_type - это std::vector<int> в данном случае
array[0][1] = 10;

Код

int i, n, m;
//вводим n и m с клавиатуры
...
//выделяем память под массив указателей
std::vector<int> array(m*n);
//теперь можно получить доступ к каждому элементу двумерного массива: array[i*m + j], где 0 <= i < n, 0 <= j < m
...

Правда, за счет сокращения объемов выделяемой памяти, сократилась и скорость доступа к элементам из-за появления операции умножения.
Можно совместить два этих способа:

Код

typedef std::vector<int> IntArray;
typedef std::vector<IntArray::iterator> IntArrayIndexes;
IntArray array;
IntArrayIndexes indexes;
int m, n;
//вводим m и n
array.resize(m*n);
indexes.resize(n);
for(IntArrayIndexes::iterator i = indexes.begin(); i != indexes.end(); ++i)
     *i = array.begin() + (i - indexes.begin()) * m;

В данном случае создается массив индексов строк indexes. Данный способ имеет по одному преимуществу, по сравнению с двумя предыдущими: во-первых, скорость доступа к каждому элементу такая же, как и в первом способе, во-вторых, скорость создания/удаления массива несколько медленней, чем во втором способе, но выше, чем в первом.

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

Код

int (*pArray)[10]; // круглые скобки обязательны

Код

double (*pArray)[5][10];

Код

typedef int (*ArrayRow)[10];
ArrayRow pArray;
pArray = new ArrayRow[50];

В данном случае памяти было выделено на 50 строк. Так как память выделяется непрерывным куском и компилятор языка Си++ не осуществляет проверки выхода за границы массива, то этот прием позволяет получить доступ ко всем строкам массива так, как это делается в статических массивах:

Код

#include <iomanip>

int main()
{
        int rowCount = 0;
        std::cin >> rowCount;
        if (rowCount <= 0)
             rowCount = 1; //нельзя выделить память под менее, чем одну строку
        int (*p)[10] = new int[rowCount][10];
        for(int i = 0; i < rowCount; ++i)
                for(int j = 0; j < 10; ++j)
                        p[i][j] = i * 10 + j;
        for(int i = 0; i < rowCount; ++i) {
                for(int j = 0; j < 10; ++j)
                        std::cout << std::setw(3) << p[i][j] << ' ';
                std::cout << std::endl;
        }
        delete []p;
        return 0;
}

http://forum.vingrad.ru/index.php?show_type=forum&showtopic=269794&kw=faq-c++

Автор: archimed7592 26.12.2007, 22:35

bsa, а где-же new/delete? smile

Ещё, прошу добавить ссылки:
1. На википедию(массив)
2. На cppreference.com или куда-нибудь ещё(malloc, free, realloc и т.д.)

Автор: Damarus 27.12.2007, 01:21

bsa, можно ещё написать про многомерные динамические массивы.

Автор: archimed7592 27.12.2007, 01:35

Damarus, согласен - а я проглядел smile

. Достаточно будет двухмерного.

Автор: Shaggie 28.12.2007, 13:43

Скорее всего, на момент чтения ФАКа информация для читающего будет очень новая и неизвестная. Поэтому следующие моменты немножко напрягли:

Цитата(bsa @ 26.12.2007, 22:07

)

std::vector<int> array(n); //создаем массив из n элементов

Цитата(bsa @ 26.12.2007, 22:07

)

for(std::vector<int>::const_iterator i = array.begin(); i != array.end(); ++i)
std::cout << *i << " "; //выводим все элементы массива через пробел в одну строчку

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

Автор: archimed7592 3.1.2008, 12:39

Внимательно прочитал статью. Всё отлично. Есть только одно замечание.

Цитата(bsa @ 26.12.2007, 22:07

)

Создать динамический многомерный массив средствами языка невозможно.

Зависит от того, что именно понимать под многомерным дин. массивом. Есть способ динамически создать многомерный массив у которого только лишь одна из размерностей будет переменной. В статье этот момент нужно проговорить(возможно, привести пример).

Автор: bsa 3.1.2008, 13:36

archimed7592, ты имеешь в виду что-то типа:

Код

int (*p)[1][10] = (int (*)[1][10])malloc( sizeof(*p)*10 )

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

Автор: archimed7592 3.1.2008, 14:35

Цитата(bsa @ 3.1.2008, 13:36

)

ты имеешь в виду что-то типа:

Да. На С++ это будет выглядеть так:

Код


int n;
std::cin >> n;
int (*arr)[5][6] = new int [n][5][6];

Теория тут следующая:
1. Скорость доступа [почти] такая же как у статических массивов.
2. Скорость создания такая же, как у одномерного динамического массива.
3. arr[i][j][k] == *((int *)arr + (i * 5 + j) * 6 + k) (могу ошибаться, но вроде так) - компилятор сам делает эти вычисления(как и со статическими массивами).
4. При создании такого массива, динамической может быть только первая(крайняя левая) размерность(остальные константы).

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

Автор: archimed7592 3.1.2008, 15:29

Цитата(bsa @ 26.12.2007, 22:07

)

#define ROW_COUNT 50

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

Автор: JackYF 3.1.2008, 16:33

Извиняюсь за занудность, но я же назначался вычитщиком? smile

Цитата(bsa @ 26.12.2007, 22:07

)

Массив это набор

Массив - это набор

Цитата(bsa @ 26.12.2007, 22:07

)

а последний (N-1)

а последний - (N-1)

Цитата(bsa @ 26.12.2007, 22:07

)

Таким образом для

таким образом, для

Цитата(bsa @ 26.12.2007, 22:07

)

достаточно, для организации

достаточно для организации

Цитата(bsa @ 26.12.2007, 22:07

)

Разве что sizeof(p) вернет размер

Разве что, sizeof(p) ...

Цитата(bsa @ 26.12.2007, 22:07

)

И чтобы избежать утечек памяти нужно

И, чтобы избежать утечек памяти, нужно

Цитата(bsa @ 26.12.2007, 22:07

)

Чтобы этого не происходило нужно опять воспользоваться функцией memcpy():

... не происходило, нужно ...

Цитата(bsa @ 26.12.2007, 22:07

)

Для работы с ним, требуется подключить специальный модуль:

запятая не нужна

Цитата(bsa @ 26.12.2007, 22:07

)

Но можно сэмитировать одним из двух способов:

сЫмитировать

У меня всё, сама статья понравилась.

Добавлено через 2 минуты и 43 секунды

Цитата(archimed7592 @ 3.1.2008, 16:20

)

то отправлю к главреду

P.S. а кто главред?

Автор: Alexeis 3.1.2008, 16:55

Хотелось бы еще про динамические строки, как частный случай массивов переменной длинны.

Цитата(JackYF @ 3.1.2008, 15:33

)

P.S. а кто главред?

Напрашивается ГлавВред smile

Автор: archimed7592 3.1.2008, 17:01

Цитата(JackYF @ 3.1.2008, 16:33

)

P.S. а кто главред?

Ты

Цитата(Alexeis @ 3.1.2008, 16:55

)

Хотелось бы еще про динамические строки, как частный случай массивов переменной длинны.

Только если отдельной статьёй, а то слишком много получится(разве о них не написано в прикреплённой теме "указатели, строки, классы"?)

Автор: bsa 3.1.2008, 17:14

Цитата(Alexeis @ 3.1.2008, 16:55)

Хотелось бы еще про динамические строки, как частный случай массивов переменной длинны.

Не. Разве что разместить ссылку на статью про строки, как частный вариант массивов. Но не более того.
А то мне уже самому страшно смотреть на то, что получилось - ОЧЕНЬ МНОГО!

Добавлено @ 17:16

Цитата(man 3 alloca)

CONFORMING TO
There is evidence that the alloca() function appeared in 32v, pwb, pwb.2, 3bsd, and 4bsd. There is a man page for it in 4.3BSD. Linux
uses the GNU version. This function is not in POSIX.1-2001.

Думаю, упоминать alloca не стоит.

archimed7592: Оффтоп про alloca перенесён в отдельную http://forum.vingrad.ru/index.php?showtopic=190823.

Автор: Fazil6 3.1.2008, 17:48

Цитата(bsa @ 26.12.2007, 21:07

)

В языке С++ есть встроенные средства, для работы с динамической памятью - new[] и delete[]. Это аналоги calloc и free соответственно:

Цитата(bsa @ 26.12.2007, 21:07

)

Но пользоваться ими не сильно удобней, чем аналогами из Си.

хм... почему это?
Вообще тема new/delete нераскрыта...
Лучше статья будет читаться, если разбить ее хотябы на подразделы с собственными подзаголовками причем раз уж пытаешься объять необъятное, то четко разделить C и С++, а вообще как и раньше мои претензии по объему.
Опять же я, например, так и не понял почему рассмотрение началось с функции realloc , а не calloc и резонный вопрос почему для выделения памяти существуют 2 функции

Цитата(bsa @ 26.12.2007, 21:07

)

malloc, calloc - выделение памяти

Автор: archimed7592 10.1.2008, 22:51

Цитата(bsa @ 26.12.2007, 22:07

)

int *p = (int*)calloc(256, sizeof(*p)); //выделение памяти под 256 элементов типа int
//это эквивалентно записи
int *p = (int*)malloc(256*sizeof(*p));

Ты уверен, что это эквивалентно? ;)
Могу заблуждаться, но, IIRC, помимо всего прочего, calloc инициализирует выделенную область памяти нулями.

Цитата(bsa @ 26.12.2007, 22:07

)

realloc() функция другого уровня. Она позволяет выделять, освобождать и изменять размер области памяти, которая выделена функциями realloc(), malloc() или calloc():

У меня будет маленькая просьба, относительно realloc: либо из статьи вообще убрать упоминания(как в тексте, так и в коде) о том, что с помощью realloc можно и выделять и освобождать память, либо вынести это в примечание. Для этого есть несколько причин:
1. Информация "излишняя" т.е., воспользовавшись этой информацией, новичек не сможет сделать ничего такого чего он не мог бы сделать с помощью malloc+free.
2. Использовать realloc как универсальную ф-цию нужно в достаточно редких случаях и отличить эти случаи от тех, где надо бы воспользоваться malloc+free сможет не каждый новичек, а, как следствие, статья некоторых новичков статья научит плохому стилю, чего хотелось бы не допускать.

И ещё одна просьба: насколько я понял ты отделил Си от С++(я чесслово уже не помню как было прежде). Дык вот, информация о многомерных массивах осталась в "смешанном" виде - нужно разделить. Потом посмотрим, но учти, что, скорее всего, будем делить на две статьи(одна для Си, другая для плюс-плюс).

Добавлено @ 22:53
Кстати, если про calloc не заблуждаюсь, то неплохо было бы об этом написать.

M
archimed7592

Немного почикал тему. Не обижайтесь, чьи неинформативные посты поудалял - свои удалил тоже :-D.

Автор: bsa 10.1.2008, 23:30

Цитата(archimed7592 @ 10.1.2008, 22:51)

Кстати, если про calloc не заблуждаюсь, то неплохо было бы об этом написать.

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

Автор: bsa 11.1.2008, 12:04

Кстати, если статью разделять на С и С++, то, получается, придется копировать теорию, которая в целом общая.

Автор: JackYF 11.1.2008, 14:28

Цитата(bsa @ 11.1.2008, 11:04

)

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

хм...
а может, давайте оставим одну статью, но сделаем у неё три больших заголовка: "Общая теория", "Применение в С", "Применение в С++".
И структирированно будет, и материалы по одному вопросу в одном месте.

Автор: archimed7592 11.1.2008, 14:40

Цитата(bsa @ 11.1.2008, 12:04

)

Кстати, если статью разделять на С и С++, то, получается, придется копировать теорию, которая в целом общая.

Не обязательно. Просто в С++ дать ссылку на С(мол, не понимаете о чём речь, прочтите сначала "это").

Цитата(JackYF @ 11.1.2008, 14:28

)

а может, давайте оставим одну статью, но сделаем у неё три больших заголовка: "Общая теория", "Применение в С", "Применение в С++".

Идея интересная, но я вот боюсь представить, что будет, если вдруг захочется добавить к этим динамическим массивам что-нибудь ещё - я и так устаю, пока скрол прокручиваю smile

...

Может быть просто разделить
1. одномерные
2. двухмерные
3. что-то ещё(уверен, что в скором будущем понадобится добавлять).
и внрутри этих, уже более маленьких статей делать три мега-заголовка?
Просто динамические массивы сами по себе тема достаточно обширная(для новичков) smile

Автор: bsa 11.1.2008, 17:06

Цитата(archimed7592 @ 11.1.2008, 14:40)

Может быть просто разделить
1. одномерные
2. двухмерные
3. что-то ещё(уверен, что в скором будущем понадобится добавлять).
и внрутри этих, уже более маленьких статей делать три мега-заголовка?
Просто динамические массивы сами по себе тема достаточно обширная(для новичков) smile

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

Автор: archimed7592 11.1.2008, 17:10

Цитата(bsa @ 11.1.2008, 17:06

)

Во-первых, смысла писать про двумерные нет никакого. Думаю, надо написать про многомерные на примере двумерных.

Ну да, я хотел написать многомерные smile

Цитата(bsa @ 11.1.2008, 17:06

)

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

Ок, а с чего ты взял, что читающий не знает как создаются одномерные? ;)
Ведь часто встречаются вопросы "вот так одномерные, а двумерные как?". Ну а если читающий действительно не знает, то ничто не мешает дать ссылку на одномерные(в самом начале).

Автор: xvr 25.1.2008, 16:49

Хочу добавить свои 5 коп (если еще не поздно).

Было бы неплохо упомянуть где-нибудь (желательно поближе к началу), что крайне не рекомендуется получать указатели на элементы динамических массивов (как созданных через malloc/realloc, так и к их STL братьям vector), т.к. адреса как собственно массивов так и их элементов могут меняться при изменении размера массивов. А указатели на элементы, сохраненные где-то в стороне приводят к труднонаходимым ошибкам.

По этим граблям ходят довольно много народу smile

Автор: JackYF 25.1.2008, 17:26

Цитата(xvr @ 25.1.2008, 15:49

)

Было бы неплохо упомянуть где-нибудь (желательно поближе к началу), что крайне не рекомендуется получать указатели на элементы динамических массивов (как созданных через malloc/realloc, так и к их STL братьям vector), т.к. адреса как собственно массивов так и их элементов могут меняться при изменении размера массивов. А указатели на элементы, сохраненные где-то в стороне приводят к труднонаходимым ошибкам.

Да, поддерживаю.

Автор: archimed7592 25.1.2008, 17:28

Это конечно всё очень хорошо, но, куда же подевался bsa :'( .

Автор: bsa 28.1.2008, 18:31

archimed7592, я тут. А что?

Автор: archimed7592 28.1.2008, 18:54

Цитата(bsa @ 28.1.2008, 18:31

)

А что?

Цитата

И ещё одна просьба: насколько я понял ты отделил Си от С++(я чесслово уже не помню как было прежде). Дык вот, информация о многомерных массивах осталась в "смешанном" виде - нужно разделить. Потом посмотрим, но учти, что, скорее всего, будем делить на две статьи(одна для Си, другая для плюс-плюс).

Автор: bsa 29.1.2008, 11:33

Вообще-то там все в едином стиле. Т.е. сначала капелька теории, затем Си и в конце Си++. Просто про многомерные массивы там 3 варианта написано. Вот и чередуются.
Может мне просто сразу разделить статьи на две?

Автор: archimed7592 29.1.2008, 12:01

Цитата(bsa @ 29.1.2008, 11:33

)

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

Автор: bsa 29.1.2008, 15:27

Разделил статью. Проверяйте - у меня уже глаза не смотрит.

Автор: JackYF 29.1.2008, 16:04

Цитата(bsa @ 29.1.2008, 14:27

)

Проверяйте - у меня уже глаза не смотрит.

У меня тоже, только причина другая. Просмотрел навскидку - всё вроде логично и разделено получилось.

Автор: bsa 29.1.2008, 20:24

Цитата(JackYF @ 29.1.2008, 16:04)

У меня тоже, только причина другая. Просмотрел навскидку - всё вроде логично и разделено получилось.

Откуда знаешь? может у меня та же smile

Автор: JackYF 29.1.2008, 20:48

Цитата(bsa @ 29.1.2008, 19:24

)

может у меня та же

ты тоже вчера активно "горку" праздновал? smile

Автор: archimed7592 29.1.2008, 20:51

Ребят, кончай флеймить smile

.

bsa, молодец. Подробно посмотреть смогу только завтра...

Автор: JackYF 29.1.2008, 22:01

Цитата(archimed7592 @ 29.1.2008, 19:51

)

Ребят, кончай флеймить

один фиг, кроме нас пока эту тему никто не читает smile

Автор: bsa 30.1.2008, 11:40

JackYF, не - я ничего не праздновал. Просто уже опух от компов. smile

Автор: archimed7592 30.1.2008, 14:56

Си:

Цитата(bsa @ 26.12.2007, 22:07

)

do { //на самом деле реализация функции realloc() несколько сложней
   int *t = (int*)calloc(100, sizeof(*p)); //выделение памяти под 100 элементов типа int
   memcpy(t, p, 10*sizeof(*p)); //копирование содержимого предыдущего массива в новый
   free(p); //освобождение памяти от предыдущего массива
   p = t; //присвоение p указателя на новый массив
}while(0);

Эммм... В чём идея применения do..while(0)?

Цитата(bsa @ 26.12.2007, 22:07

)

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

Мне кажется что нужно убрать эту информацию: на начальном этапе новичку не нужно знать этой информации, ибо это может привести к мыслям "а всё равно в конце само по себе освободится", а на продвинутом этапе программист так или иначе сам узнаёт эту информацию без помощи ФАКа smile

Цитата(bsa @ 26.12.2007, 22:07

)

Хотелось бы отметить опасность широкого использования указателей на внутренние элементы массивов с изменяемым количеством элементов.

Мне не совсем понятен смысл слова "широкого" - "узкое" использование безопасно что ль? smile

Цитата(bsa @ 26.12.2007, 22:07

)

Как нетрудно заметить, сократился объем выделяемой памяти, но зато сократилась и скорость доступа к элементам.

Почему это вдруг скорость сократилась? smile

Цитата(bsa @ 26.12.2007, 22:07

)

    //можно это сделать так:
    //p = (int*)realloc( NULL, n*sizeof(*p) );
    //или так:
    //p = (int*)calloc( n, sizeof(*p) ); //хотя в этом случае будет сделано лишнее - обнуление массива
    .....
    //но можно освободить память и так:
    //realloc(p, 0); // это удобно, когда изменение размера массива делает одна функция

Чуть выше я приводил пару аргументов, почему на мой взгляд этого не должно быть в статье... можно увидеть какие-нибудь контраргументы, которые заставили тебя оставить эти строки? smile

Добавлено через 2 минуты и 54 секунды

Цитата(JackYF @ 29.1.2008, 22:01

)

один фиг, кроме нас пока эту тему никто не читает smile

Учитывая то, что она прибита к потолку, я бы хорошенько подумал, прежде чем делать такие выводы smile

Автор: bsa 30.1.2008, 16:58

Поправил.