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



не могу понять почему, ведь я передаю указатель, причем когда память выделяется "сверху" функции, то всё как и ожидается

т.е. когда 


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

так тоже работает.


или это всё специфика передачи массива?

Это сообщение отредактировал(а) mrgloom - 20.8.2013, 14:54

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

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

Вывод:

Это сообщение отредактировал(а) SenkraD - 20.8.2013, 14:55

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

получается что нужно передавать указатель по ссылке? или указатель на указатель?

вообщем тут вот ответ
http://www.codeproject.com/Articles/4894/P...ence-to-Pointer

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

кстати, это не мешает вам удалить то, на что указывает указатель:но лучше таки так:

Это сообщение отредактировал(а) SenkraD - 20.8.2013, 15:09

по-хорошему, лучше так не делать. Удалять надо там же, где и выделять. Иначе потом можно кучу проблем огрести.
mrgloom, посмотри описание функции realloc. Такой подход тоже можно использовать.

ну это с тех времен, когда смарт поинтеры еще были не так популярны или их нельзя было использовать или их не было в проекте. Плюс несколько раз приходилось писать кустомный делетеры для boost::shared_ptr

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

Ну, собсвенно,  такие функции часто бывают в библиотеках:так как память должна освождаться там, где выделяется + нужна, зачастую,  для  поддержки binary interface compatibility

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

как раз с delete[] похоже и выявилась проблема, долго не мог понять в чем дело, потом нашел




похоже в моем случае это связано как раз с dll, как решаются такие проблемы?

самое простое вроде как передавать std::vector<std::vector<char>>

еще заметил что если сделать так

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

ну да дебагер ее видит как строку, но сам массив не зануляется.



в чем именно это выраженно? общее правило при работе с dll такие:

• типы линковки в dll и модуле, который ее использует должны совпадать
• память, выделяется в dll, должна в ней и освобождаться: например: T* getObject() и void destroyObject(T* object)
• не возвращаем с интерфейсов dll STL контейнеры, уоторые можно изменять не средствами dll

после delete/delete[] указателю лучше присваивать NULL/nullptr, если возможен даблделит, так как их удаленние определенно стандартом и считается валидным

Это сообщение отредактировал(а) SenkraD - 21.8.2013, 11:14

Никак. В С и С++ массив (точнее область памяти), выделенный с помощью new и/или malloc, уже не может изменить свой размер. Так что сколько вы ему памяти при создании дали, столько в нем и будет, и никакая функция этого изменить не сможет.
Что же касается функции realloc, то она как ни странно не увеличивает размер массива, а содает новый массив (по другому адресу), и копирует в него содержимое старого массива. Т.е. адрес массива после нее может измениться.

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


А может и не измениться

Добавлено через 7 минут и 45 секунд
И вообще здесь начните с объяснения, как в С просто передаются параметры в функцию.

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

Добавлено через 13 минут и 51 секунду


сам стиль плох. потому что вызовом new(malloc и т.д.) уже в одну строчку выделяется память

Это сообщение отредактировал(а) akizelokro - 24.8.2013, 13:59

давай мыслить логически как выглядит переменная. переменная состоит из двух частей [адрес в памяти][значение]
передаётся в функцию по копии то есть, создаётся копия переменной.
что такое указатель это тоже самое, только во второй части у него лежит адрес.
что передаётся в функцию если переменная ровна нулю, правильно делается копия. но значение у нас ноль [адрес в памяти][NULL];
в это 0 мы выделяем память, то есть там не ноль а адрес. вот тут и получается прикол что твоя переменная ( p ) понятия не имеет о выделенной памяти у неё значение 0;
в копию мы выделили память а в переменной так и осталось значение 0;
рассуждаем дальше что нам надо для того чтоб можно было выделить память, нужно сделать указатель на указатель
то есть нужно чтоб сюда в значение попал адрес переданной переменной [адрес в памяти][значение]. и получается что-то такого типа [адрес копии][адрес переданного указателя][значение переданного указателя (не копия)]. вот вам два способа как этого добиться:


  

Это сообщение отредактировал(а) aleksandrkr - 19.9.2013, 14:17

Это очень смелое утверждение   

да я с вами согласен я не совсем точно объяснил, точнее я немного исказил реальность дабы донести суть проблемы до новичка.
правда на самом деле в переменной хорониться только адрес в памяти.    
 
int P = 10;
cout << &P <<endl; //адресс
cout <<P <<endl; //значение;

http://www.firststeps.ru/asm/r.php?35 

Это сообщение отредактировал(а) aleksandrkr - 19.9.2013, 17:23

Это в указателе хранится адрес. А вот массив - это не указатель. Он может быть приведен к указателю (явно или не явно). Но фактически это единая переменная. Переменная - это просто набор данных в памяти. И естественно, известен ее адрес. Другое дело, что адрес может ВЫЧИСЛЯТЬСЯ в процессе работы программы или может быть вшит в нее жестко. Поэтому утверждение о том, что переменная состоит из двух частей имеет столько же смысла, сколько: "моя квартира состоит из двух частей: адрес и помещение".

1)переменная типа массив это указатель на его первый элемент.
int arr[10] ={0};
int * p = arr + (sizeof(int) * 4) ; аналогично записи arr[4];
2)int pr; эта запись в процессе компиляции будет заменена на
asm
{

MODEL SMALL
STACK 256
DATASEG

Data1 DB 31h    ; выделить один байт с содержимым 31h

CODESEG
Start:

mov ax,@data ; установка в ds адреса
mov ds,ax ; сегмента данных
mov ax,OFFSET Data1 ; где находиться переменная

End Start

}

компилятор сам просчитает где ляжет переменная и везде где он встретит pr он заменит pr на полученный адрес 0xbfd86d6c
Указатель — это переменная, содержащая адрес некоторого элемента данных (переменной, константы, функции, структуры). В языке C указатели тесно связаны с обработкой массивов и строк  

Бьерн Страуструп. Язык программирования С++
    1.3.2 Переменные и арифметические операции



    Каждое имя и каждое выражение обязаны иметь тип. Именно тип определяет
операции, которые могут выполняться над ними. Например, в описании

    int inch;

    говорится, что inch имеет тип int, т.е. inch является целой
переменной.

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

    Основные типы, наиболее приближенные к "аппаратной реальности" машины,
таковы:

              char
              short
              int
              long

    Они представляют целые числа.  Следующие типы:

              float
              double
              long double

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

    Следующие арифметические операции можно использовать над любым
сочетанием перечисленных типов:

            +    (плюс, унарный и бинарный)
            -    (минус, унарный и бинарный)
            *    (умножение)
            /    (деление)
            %    (остаток от деления)

    То же верно для операций отношения:

            ==   (равно)
            !=   (не равно)
            <    (меньше чем)
            <=   (меньше или равно)
            >=   (больше или равно)

    Для операций присваивания и арифметических операций в С++ выполняются
все осмысленные преобразования основных типов, чтобы их можно было
неограниченно использовать любые их сочетания:

            double d;
            int i;
            short s;
            // ...
            d = d + i;
            i = s * i;

    Символ = обозначает обычное присваивание.


    1.3.3 Указатели и массивы



    Массив можно описать так:

    char v [ 10 ]; // массив из 10 символов

    Описание указателя имеет такой вид:

    char * p; // указатель на символ

    Здесь [] означает "массив из", а символ * означает "указатель на".
Значение нижней границы индекса для всех массивов равно нулю, поэтому v
имеет 10 элементов: v [ 0 ] ... v [ 9 ]. Переменная типа указатель может
содержать адрес объекта соответствующего типа:

    p = & v [ 3 ]; // p указывает на 4-й элемент массива v

    Унарная операция & означает взятие адреса.
 

Ну вот зачем такое писать   

точно извиняюсь sizeof лишний 


Добавлено через 7 минут и 20 секунд
у кого нибудь стоит 6 студия.
проверти эту запись.  short * p = arr + 4;
оно правильно отработает или нет.

Добавлено через 8 минут и 44 секунды
по идеи оно работать не должно.

Это почему?

Это не так. Массив ведет себя аналогично указателю в большинстве случаев. Но в ряде случаев он отличается: передача массива в качестве параметра шаблонной функции, sizeof. Поэтому нельзя говорить, что массив это указатель.

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