Когда следует использовать двойную косвенность в C? Кто-нибудь может объяснить на примере?
Что я знаю, так это то, что двойное косвенное обращение - это указатель на указатель. Зачем мне нужен указатель на указатель?
Когда следует использовать двойную косвенность в C? Кто-нибудь может объяснить на примере?
Что я знаю, так это то, что двойное косвенное обращение - это указатель на указатель. Зачем мне нужен указатель на указатель?
Ответы:
Если вы хотите иметь список символов (слово), вы можете использовать char *word
Если вы хотите список слов (предложение), вы можете использовать char **sentence
Если вы хотите список предложений (монолог), вы можете использовать char ***monologue
Если вы хотите список монологов (биография), вы можете использовать char ****biography
Если вы хотите список биографий (биобиблиотеки), вы можете использовать char *****biolibrary
Если вы хотите список биобиблиотек (a lol), вы можете использовать char ******lol
... ...
да, я знаю, что это могут быть не самые лучшие структуры данных
Пример использования с очень очень очень скучным лол
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int wordsinsentence(char **x) {
int w = 0;
while (*x) {
w += 1;
x++;
}
return w;
}
int wordsinmono(char ***x) {
int w = 0;
while (*x) {
w += wordsinsentence(*x);
x++;
}
return w;
}
int wordsinbio(char ****x) {
int w = 0;
while (*x) {
w += wordsinmono(*x);
x++;
}
return w;
}
int wordsinlib(char *****x) {
int w = 0;
while (*x) {
w += wordsinbio(*x);
x++;
}
return w;
}
int wordsinlol(char ******x) {
int w = 0;
while (*x) {
w += wordsinlib(*x);
x++;
}
return w;
}
int main(void) {
char *word;
char **sentence;
char ***monologue;
char ****biography;
char *****biolibrary;
char ******lol;
//fill data structure
word = malloc(4 * sizeof *word); // assume it worked
strcpy(word, "foo");
sentence = malloc(4 * sizeof *sentence); // assume it worked
sentence[0] = word;
sentence[1] = word;
sentence[2] = word;
sentence[3] = NULL;
monologue = malloc(4 * sizeof *monologue); // assume it worked
monologue[0] = sentence;
monologue[1] = sentence;
monologue[2] = sentence;
monologue[3] = NULL;
biography = malloc(4 * sizeof *biography); // assume it worked
biography[0] = monologue;
biography[1] = monologue;
biography[2] = monologue;
biography[3] = NULL;
biolibrary = malloc(4 * sizeof *biolibrary); // assume it worked
biolibrary[0] = biography;
biolibrary[1] = biography;
biolibrary[2] = biography;
biolibrary[3] = NULL;
lol = malloc(4 * sizeof *lol); // assume it worked
lol[0] = biolibrary;
lol[1] = biolibrary;
lol[2] = biolibrary;
lol[3] = NULL;
printf("total words in my lol: %d\n", wordsinlol(lol));
free(lol);
free(biolibrary);
free(biography);
free(monologue);
free(sentence);
free(word);
}
Вывод:
всего слов в моем лол: 243
arr[a][b][c]
не так ***arr
. Указатель указателей использует ссылки ссылок, в то время arr[a][b][c]
как хранится как обычный массив в порядке следования строк.
Одна из причин заключается в том, что вы хотите изменить значение указателя, переданного функции в качестве аргумента функции, для этого вам потребуется указатель на указатель.
Проще говоря, используйте, **
если вы хотите сохранить (ИЛИ сохранить изменение) Распределение памяти или Назначение даже вне вызова функции. (Итак, передайте такую функцию с двойным указателем arg.)
Это может быть не очень хороший пример, но покажет вам основное использование:
void allocate(int** p)
{
*p = (int*)malloc(sizeof(int));
}
int main()
{
int* p = NULL;
allocate(&p);
*p = 42;
free(p);
}
void allocate(int *p)
и вы назвали это как allocate(p)
?
pointer1 = pointer2
вы даете указателю1 адрес указателя2.но! если вы делаете это внутри функции и хотите, чтобы результат сохранялся после выполнения функции, вам нужно проделать дополнительную работу. вам нужен новый указатель3 только для указания на указатель1. передать указатель 3 в функцию.
вот пример. сначала посмотрите на вывод ниже, чтобы понять.
#include <stdio.h>
int main()
{
int c = 1;
int d = 2;
int e = 3;
int * a = &c;
int * b = &d;
int * f = &e;
int ** pp = &a; // pointer to pointer 'a'
printf("\n a's value: %x \n", a);
printf("\n b's value: %x \n", b);
printf("\n f's value: %x \n", f);
printf("\n can we change a?, lets see \n");
printf("\n a = b \n");
a = b;
printf("\n a's value is now: %x, same as 'b'... it seems we can, but can we do it in a function? lets see... \n", a);
printf("\n cant_change(a, f); \n");
cant_change(a, f);
printf("\n a's value is now: %x, Doh! same as 'b'... that function tricked us. \n", a);
printf("\n NOW! lets see if a pointer to a pointer solution can help us... remember that 'pp' point to 'a' \n");
printf("\n change(pp, f); \n");
change(pp, f);
printf("\n a's value is now: %x, YEAH! same as 'f'... that function ROCKS!!!. \n", a);
return 0;
}
void cant_change(int * x, int * z){
x = z;
printf("\n ----> value of 'a' is: %x inside function, same as 'f', BUT will it be the same outside of this function? lets see\n", x);
}
void change(int ** x, int * z){
*x = z;
printf("\n ----> value of 'a' is: %x inside function, same as 'f', BUT will it be the same outside of this function? lets see\n", *x);
}
Вот результат: ( сначала прочтите это )
a's value: bf94c204
b's value: bf94c208
f's value: bf94c20c
can we change a?, lets see
a = b
a's value is now: bf94c208, same as 'b'... it seems we can, but can we do it in a function? lets see...
cant_change(a, f);
----> value of 'a' is: bf94c20c inside function, same as 'f', BUT will it be the same outside of this function? lets see
a's value is now: bf94c208, Doh! same as 'b'... that function tricked us.
NOW! lets see if a pointer to a pointer solution can help us... remember that 'pp' point to 'a'
change(pp, f);
----> value of 'a' is: bf94c20c inside function, same as 'f', BUT will it be the same outside of this function? lets see
a's value is now: bf94c20c, YEAH! same as 'f'... that function ROCKS!!!.
В дополнение к ответу Аши , если вы используете единственный указатель на приведенный ниже пример (например, alloc1 ()), вы потеряете ссылку на память, выделенную внутри функции.
void alloc2(int** p) {
*p = (int*)malloc(sizeof(int));
**p = 10;
}
void alloc1(int* p) {
p = (int*)malloc(sizeof(int));
*p = 10;
}
int main(){
int *p = NULL;
alloc1(p);
//printf("%d ",*p);//undefined
alloc2(&p);
printf("%d ",*p);//will print 10
free(p);
return 0;
}
Причина, по которой это происходит, заключается в alloc1
том, что указатель передается по значению. Таким образом, когда оно переназначается на результат malloc
вызова внутри alloc1
, изменение не относится к коду в другой области видимости.
free(p)
не достаточно, вам if(p) free(*p)
тоже нужно
*p
Оценивает int
значение 10, передавая int
его free () `- плохая идея.
alloc1()
вводит утечку памяти. Значение указателя, которое должно быть передано свободно, теряется при возврате из функции.
Сегодня я увидел очень хороший пример из этого поста в блоге , который я подытожил ниже.
Представьте, что у вас есть структура для узлов в связанном списке, которая, вероятно,
typedef struct node
{
struct node * next;
....
} node;
Теперь вы хотите реализовать remove_if
функцию, которая принимает критерий удаления в rm
качестве одного из аргументов и пересекает связанный список: если запись удовлетворяет критерию (что-то вроде rm(entry)==true
), ее узел будет удален из списка. В конце remove_if
возвращает заголовок (который может отличаться от исходного заголовка) связанного списка.
Вы можете написать
for (node * prev = NULL, * curr = head; curr != NULL; )
{
node * const next = curr->next;
if (rm(curr))
{
if (prev) // the node to be removed is not the head
prev->next = next;
else // remove the head
head = next;
free(curr);
}
else
prev = curr;
curr = next;
}
как ваша for
петля. Сообщение состоит в том, что без двойных указателей вам нужно поддерживать prev
переменную для реорганизации указателей и обрабатывать два разных случая.
Но с двойными указателями, вы можете написать
// now head is a double pointer
for (node** curr = head; *curr; )
{
node * entry = *curr;
if (rm(entry))
{
*curr = entry->next;
free(entry);
}
else
curr = &entry->next;
}
Вам не нужно prev
сейчас, потому что вы можете напрямую изменить то, prev->next
на что указывает .
Чтобы прояснить ситуацию, давайте немного следуем коду. Во время удаления:
entry == *head
: это будет *head (==*curr) = *head->next
- head
теперь указывает на указатель нового узла заголовка. Вы делаете это путем непосредственного изменения head
содержимого на новый указатель.entry != *head
: аналогично, *curr
это то , на что prev->next
указывает, а теперь указывает на entry->next
.Независимо от того, в каком случае вы можете реорганизовать указатели единым образом с двойными указателями.
1. Основная концепция -
Когда вы заявляете следующее: -
1. char * ch - (вызываемый символьный указатель)
- ch содержит адрес одного символа.
- (* ch) будет ссылаться на значение символа.
2. char ** ch -
'ch' содержит адрес массива указателей символов. (как в 1)
'* ch' содержит адрес одного символа. (Обратите внимание, что это отличается от 1, из-за разницы в объявлении).
(** ch) будет разыменовывать точное значение символа.
Добавление дополнительных указателей расширяет размерность типа данных, от символа до строки, до массива строк и т. Д. Вы можете связать его с 1d, 2d, 3d матрицей.
Таким образом, использование указателя зависит от того, как вы его объявите.
Вот простой код
int main()
{
char **p;
p = (char **)malloc(100);
p[0] = (char *)"Apple"; // or write *p, points to location of 'A'
p[1] = (char *)"Banana"; // or write *(p+1), points to location of 'B'
cout << *p << endl; //Prints the first pointer location until it finds '\0'
cout << **p << endl; //Prints the exact character which is being pointed
*p++; //Increments for the next string
cout << *p;
}
2. Другое применение двойных указателей -
(это также относится к передаче по ссылке)
Предположим, вы хотите обновить персонажа из функции. Если вы попробуете следующее: -
void func(char ch)
{
ch = 'B';
}
int main()
{
char ptr;
ptr = 'A';
printf("%c", ptr);
func(ptr);
printf("%c\n", ptr);
}
Выход будет АА. Это не работает, так как вы «передали по значению» в функцию.
Правильный способ сделать это будет -
void func( char *ptr) //Passed by Reference
{
*ptr = 'B';
}
int main()
{
char *ptr;
ptr = (char *)malloc(sizeof(char) * 1);
*ptr = 'A';
printf("%c\n", *ptr);
func(ptr);
printf("%c\n", *ptr);
}
Теперь расширьте это требование для обновления строки вместо символа.
Для этого вам необходимо получить параметр в функции в виде двойного указателя.
void func(char **str)
{
strcpy(str, "Second");
}
int main()
{
char **str;
// printf("%d\n", sizeof(char));
*str = (char **)malloc(sizeof(char) * 10); //Can hold 10 character pointers
int i = 0;
for(i=0;i<10;i++)
{
str = (char *)malloc(sizeof(char) * 1); //Each pointer can point to a memory of 1 character.
}
strcpy(str, "First");
printf("%s\n", str);
func(str);
printf("%s\n", str);
}
В этом примере метод ожидает двойной указатель в качестве параметра для обновления значения строки.
#include <stdio.h> int main() { char *ptr = 0; ptr = malloc(255); // allocate some memory strcpy( ptr, "Stack Overflow Rocks..!!"); printf("%s\n", ptr); printf("%d\n",strlen(ptr)); free(ptr); return 0; }
Но вы можете сделать это без использования двойного указателя тоже.
char
указателей. Указатель на массив char*
будет напечатан, например, так: char(*(*p)[42])
определяется p
как указатель на массив из 42 указателей на char
.
*str = ...
str
разыменовывается неинициализированный вызов неопределенного поведения.
malloc(sizeof(char) * 10);
не выделяет место для 10 указателя, char
но char
только для 10 ..
for(i=0;i<10;i++) { str = ...
пропускает использование индекса i
.
Указатели на указатели также пригодятся в качестве «дескрипторов» памяти, где вы хотите передать «дескриптор» между функциями в перемещаемую память. По сути, это означает, что функция может изменять память, на которую указывает указатель внутри переменной handle, и каждая функция или объект, использующий дескриптор, будет правильно указывать на вновь перемещенную (или выделенную) память. Библиотеки любят делать это с «непрозрачными» типами данных, то есть с типами данных, если вам не нужно беспокоиться о том, что они делают с указанной памятью, вы просто передаете «дескриптор» между функции библиотеки для выполнения некоторых операций с этой памятью ...
Например:
#include <stdlib.h>
typedef unsigned char** handle_type;
//some data_structure that the library functions would work with
typedef struct
{
int data_a;
int data_b;
int data_c;
} LIB_OBJECT;
handle_type lib_create_handle()
{
//initialize the handle with some memory that points to and array of 10 LIB_OBJECTs
handle_type handle = malloc(sizeof(handle_type));
*handle = malloc(sizeof(LIB_OBJECT) * 10);
return handle;
}
void lib_func_a(handle_type handle) { /*does something with array of LIB_OBJECTs*/ }
void lib_func_b(handle_type handle)
{
//does something that takes input LIB_OBJECTs and makes more of them, so has to
//reallocate memory for the new objects that will be created
//first re-allocate the memory somewhere else with more slots, but don't destroy the
//currently allocated slots
*handle = realloc(*handle, sizeof(LIB_OBJECT) * 20);
//...do some operation on the new memory and return
}
void lib_func_c(handle_type handle) { /*does something else to array of LIB_OBJECTs*/ }
void lib_free_handle(handle_type handle)
{
free(*handle);
free(handle);
}
int main()
{
//create a "handle" to some memory that the library functions can use
handle_type my_handle = lib_create_handle();
//do something with that memory
lib_func_a(my_handle);
//do something else with the handle that will make it point somewhere else
//but that's invisible to us from the standpoint of the calling the function and
//working with the handle
lib_func_b(my_handle);
//do something with new memory chunk, but you don't have to think about the fact
//that the memory has moved under the hood ... it's still pointed to by the "handle"
lib_func_c(my_handle);
//deallocate the handle
lib_free_handle(my_handle);
return 0;
}
Надеюсь это поможет,
Джейсон
unsigned char
специально используется, потому что мы храним указатель на двоичные данные, которые будут представлены в виде необработанных байтов. Использование void
потребует приведения в некоторый момент, и, как правило, не так читаемо, как намерение того, что делается.
int main(int argc, char **argv)
Во втором параметре он есть: указатель на указатель на символ.
Обратите внимание, что указатель notation ( char* c
) и массив notation ( char c[]
) взаимозаменяемы в аргументах функции. Таким образом, вы могли бы также написать char *argv[]
. Другими словами char *argv[]
и char **argv
взаимозаменяемы.
То, что представлено выше, на самом деле представляет собой массив последовательностей символов (аргументы командной строки, которые передаются программе при запуске).
Смотрите также этот ответ для более подробной информации о вышеупомянутой функции подписи.
char* c
) и массив notation ( char c[]
) взаимозаменяемы» (и имеют одинаковое точное значение) в аргументах функции . Однако они отличаются от внешних аргументов функции.
Например, вы можете убедиться, что когда вы освобождаете память чего-либо, вы впоследствии устанавливаете указатель на ноль.
void safeFree(void** memory) {
if (*memory) {
free(*memory);
*memory = NULL;
}
}
Когда вы вызываете эту функцию, вы вызываете ее с адресом указателя.
void* myMemory = someCrazyFunctionThatAllocatesMemory();
safeFree(&myMemory);
Сейчас myMemory
установлено значение NULL, и любая попытка его повторного использования будет совершенно очевидно неверной.
if(*memory)
иfree(*memory);
Например, если вы хотите произвольный доступ к несмежным данным.
p -> [p0, p1, p2, ...]
p0 -> data1
p1 -> data2
- в С
T ** p = (T **) malloc(sizeof(T*) * n);
p[0] = (T*) malloc(sizeof(T));
p[1] = (T*) malloc(sizeof(T));
Вы храните указатель, p
который указывает на массив указателей. Каждый указатель указывает на часть данных.
Если sizeof(T)
оно велико, может быть невозможно выделить непрерывный блок (т. Е. Используя malloc) sizeof(T) * n
байтов.
Я постоянно использую их, когда у меня есть массив объектов, и мне нужно выполнить поиск (бинарный поиск) по ним по разным полям.
Я сохраняю оригинальный массив ...
int num_objects;
OBJECT *original_array = malloc(sizeof(OBJECT)*num_objects);
Затем создайте массив отсортированных указателей на объекты.
int compare_object_by_name( const void *v1, const void *v2 ) {
OBJECT *o1 = *(OBJECT **)v1;
OBJECT *o2 = *(OBJECT **)v2;
return (strcmp(o1->name, o2->name);
}
OBJECT **object_ptrs_by_name = malloc(sizeof(OBJECT *)*num_objects);
int i = 0;
for( ; i<num_objects; i++)
object_ptrs_by_name[i] = original_array+i;
qsort(object_ptrs_by_name, num_objects, sizeof(OBJECT *), compare_object_by_name);
Вы можете создать столько отсортированных массивов указателей, сколько вам нужно, а затем использовать двоичный поиск в отсортированном массиве указателей, чтобы получить доступ к нужному объекту по имеющимся у вас данным. Исходный массив объектов может остаться несортированным, но каждый массив указателей будет отсортирован по указанному полю.
Почему двойные указатели?
Цель состоит в том, чтобы изменить то, на что ученик указывает, используя функцию.
#include <stdio.h>
#include <stdlib.h>
typedef struct Person{
char * name;
} Person;
/**
* we need a ponter to a pointer, example: &studentA
*/
void change(Person ** x, Person * y){
*x = y; // since x is a pointer to a pointer, we access its value: a pointer to a Person struct.
}
void dontChange(Person * x, Person * y){
x = y;
}
int main()
{
Person * studentA = (Person *)malloc(sizeof(Person));
studentA->name = "brian";
Person * studentB = (Person *)malloc(sizeof(Person));
studentB->name = "erich";
/**
* we could have done the job as simple as this!
* but we need more work if we want to use a function to do the job!
*/
// studentA = studentB;
printf("1. studentA = %s (not changed)\n", studentA->name);
dontChange(studentA, studentB);
printf("2. studentA = %s (not changed)\n", studentA->name);
change(&studentA, studentB);
printf("3. studentA = %s (changed!)\n", studentA->name);
return 0;
}
/**
* OUTPUT:
* 1. studentA = brian (not changed)
* 2. studentA = brian (not changed)
* 3. studentA = erich (changed!)
*/
Ниже приведен очень простой пример C ++, который показывает, что если вы хотите использовать функцию для установки указателя, указывающего на объект, вам нужен указатель на указатель . В противном случае указатель будет возвращаться к нулю .
(Ответ на C ++, но я считаю, что в Си тоже самое)
(Также для справки: Google («передать по значению c ++») = «По умолчанию аргументы в C ++ передаются по значению. Когда аргумент передается по значению, значение аргумента копируется в параметр функции.»)
Поэтому мы хотим установить указатель b
равным строке a
.
#include <iostream>
#include <string>
void Function_1(std::string* a, std::string* b) {
b = a;
std::cout << (b == nullptr); // False
}
void Function_2(std::string* a, std::string** b) {
*b = a;
std::cout << (b == nullptr); // False
}
int main() {
std::string a("Hello!");
std::string* b(nullptr);
std::cout << (b == nullptr); // True
Function_1(&a, b);
std::cout << (b == nullptr); // True
Function_2(&a, &b);
std::cout << (b == nullptr); // False
}
// Output: 10100
Что происходит на линии Function_1(&a, b);
?
«Значение» &main::a
(адрес) копируется в параметр std::string* Function_1::a
. Следовательно, Function_1::a
указатель на (то есть адрес памяти) строки main::a
.
«Значение» main::b
(адрес в памяти) копируется в параметр std::string* Function_1::b
. Поэтому в памяти теперь есть 2 из этих адресов, оба - нулевые указатели. В строке b = a;
локальная переменная Function_1::b
затем изменяется на равную Function_1::a
(= &main::a
), но переменная main::b
не изменяется. После вызова Function_1
, main::b
по - прежнему является указателем NULL.
Что происходит на линии Function_2(&a, &b);
?
Обработка a
переменной одинакова: внутри функции Function_2::a
находится адрес строки main::a
.
Но переменная b
теперь передается как указатель на указатель. «Значение» &main::b
( адрес указателя main::b
) копируется в std::string** Function_2::b
. Следовательно, внутри Function_2 разыменовываем это как *Function_2::b
получим доступ и изменим main::b
. Таким образом, строка *b = a;
на самом деле устанавливает main::b
(адрес), равный Function_2::a
(= адрес main::a
), что мы и хотим.
Если вы хотите использовать функцию для изменения объекта, будь то объект или адрес (указатель), вы должны передать указатель на этот объект. То, что вы на самом деле передаете, не может быть изменено (в области вызова), потому что сделана локальная копия.
(Исключением является , если параметр является ссылкой, например std::string& a
. Но обычно это const
. В общем, если вы звоните f(x)
, если x
это объект , вы должны быть в состоянии предположить , что f
не будет изменять x
. Но если x
это указатель, то вы должны предположим, что это f
может изменить объект, на который указывает x
.)
Немного опоздал на вечеринку, но, надеюсь, это кому-нибудь поможет.
В массивах C всегда выделяется память в стеке, поэтому функция не может возвращать (нестатический) массив из-за того, что память, выделенная в стеке, освобождается автоматически, когда выполнение достигает конца текущего блока. Это действительно раздражает, когда вы хотите иметь дело с двумерными массивами (то есть матрицами) и реализовать несколько функций, которые могут изменять и возвращать матрицы. Чтобы достичь этого, вы можете использовать указатель-указатель для реализации матрицы с динамически распределенной памятью:
/* Initializes a matrix */
double** init_matrix(int num_rows, int num_cols){
// Allocate memory for num_rows float-pointers
double** A = calloc(num_rows, sizeof(double*));
// return NULL if the memory couldn't allocated
if(A == NULL) return NULL;
// For each double-pointer (row) allocate memory for num_cols floats
for(int i = 0; i < num_rows; i++){
A[i] = calloc(num_cols, sizeof(double));
// return NULL if the memory couldn't allocated
// and free the already allocated memory
if(A[i] == NULL){
for(int j = 0; j < i; j++){
free(A[j]);
}
free(A);
return NULL;
}
}
return A;
}
Вот иллюстрация:
double** double* double
------------- ---------------------------------------------------------
A ------> | A[0] | ----> | A[0][0] | A[0][1] | A[0][2] | ........ | A[0][cols-1] |
| --------- | ---------------------------------------------------------
| A[1] | ----> | A[1][0] | A[1][1] | A[1][2] | ........ | A[1][cols-1] |
| --------- | ---------------------------------------------------------
| . | .
| . | .
| . | .
| --------- | ---------------------------------------------------------
| A[i] | ----> | A[i][0] | A[i][1] | A[i][2] | ........ | A[i][cols-1] |
| --------- | ---------------------------------------------------------
| . | .
| . | .
| . | .
| --------- | ---------------------------------------------------------
| A[rows-1] | ----> | A[rows-1][0] | A[rows-1][1] | ... | A[rows-1][cols-1] |
------------- ---------------------------------------------------------
Двойной указатель на двойной указатель A указывает на первый элемент A [0] блока памяти, элементы которого сами являются двойными указателями. Вы можете представить эти двойные указатели как строки матрицы. Вот почему каждый двойной указатель выделяет память для элементов num_cols типа double. Кроме того, A [i] указывает на i-ю строку, то есть A [i] указывает на A [i] [0], и это только первый двойной элемент блока памяти для i-й строки. Наконец, вы можете легко получить доступ к элементу в i-й строке и j-м столбце с помощью A [i] [j].
Вот полный пример, который демонстрирует использование:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/* Initializes a matrix */
double** init_matrix(int num_rows, int num_cols){
// Allocate memory for num_rows double-pointers
double** matrix = calloc(num_rows, sizeof(double*));
// return NULL if the memory couldn't allocated
if(matrix == NULL) return NULL;
// For each double-pointer (row) allocate memory for num_cols
// doubles
for(int i = 0; i < num_rows; i++){
matrix[i] = calloc(num_cols, sizeof(double));
// return NULL if the memory couldn't allocated
// and free the already allocated memory
if(matrix[i] == NULL){
for(int j = 0; j < i; j++){
free(matrix[j]);
}
free(matrix);
return NULL;
}
}
return matrix;
}
/* Fills the matrix with random double-numbers between -1 and 1 */
void randn_fill_matrix(double** matrix, int rows, int cols){
for (int i = 0; i < rows; ++i){
for (int j = 0; j < cols; ++j){
matrix[i][j] = (double) rand()/RAND_MAX*2.0-1.0;
}
}
}
/* Frees the memory allocated by the matrix */
void free_matrix(double** matrix, int rows, int cols){
for(int i = 0; i < rows; i++){
free(matrix[i]);
}
free(matrix);
}
/* Outputs the matrix to the console */
void print_matrix(double** matrix, int rows, int cols){
for(int i = 0; i < rows; i++){
for(int j = 0; j < cols; j++){
printf(" %- f ", matrix[i][j]);
}
printf("\n");
}
}
int main(){
srand(time(NULL));
int m = 3, n = 3;
double** A = init_matrix(m, n);
randn_fill_matrix(A, m, n);
print_matrix(A, m, n);
free_matrix(A, m, n);
return 0;
}
Я использовал двойные указатели сегодня, когда программировал что-то для работы, поэтому я могу ответить, почему мы должны их использовать (это первый раз, когда мне фактически пришлось использовать двойные указатели). Нам пришлось иметь дело с кодированием кадров в реальном времени, содержащихся в буферах, которые являются членами некоторых структур. В кодировщике нам пришлось использовать указатель на одну из этих структур. Проблема заключалась в том, что наш указатель изменялся, чтобы указывать на другие структуры из другого потока. Чтобы использовать текущую структуру в кодировщике, мне пришлось использовать двойной указатель, чтобы указывать на указатель, который был изменен в другом потоке. Сначала не было очевидно, по крайней мере для нас, что мы должны были использовать этот подход. Много адресов было напечатано в процессе :)).
Вы ДОЛЖНЫ использовать двойные указатели, когда работаете с указателями, которые изменены в других местах вашего приложения. Вы также можете найти двойные указатели обязательными при работе с оборудованием, которое возвращает и обращается к вам.
Сравните изменяемое значение переменной с изменяющимся значением указателя :
#include <stdio.h>
#include <stdlib.h>
void changeA(int (*a))
{
(*a) = 10;
}
void changeP(int *(*P))
{
(*P) = malloc(sizeof((*P)));
}
int main(void)
{
int A = 0;
printf("orig. A = %d\n", A);
changeA(&A);
printf("modi. A = %d\n", A);
/*************************/
int *P = NULL;
printf("orig. P = %p\n", P);
changeP(&P);
printf("modi. P = %p\n", P);
free(P);
return EXIT_SUCCESS;
}
Это помогло мне избежать возврата значения указателя, когда указатель был изменен вызываемой функцией (используется в односвязном списке).
СТАРЫЙ (плохо):
int *func(int *P)
{
...
return P;
}
int main(void)
{
int *pointer;
pointer = func(pointer);
...
}
NEW (лучше):
void func(int **pointer)
{
...
}
int main(void)
{
int *pointer;
func(&pointer);
...
}
double*
.