malloc (выделение памяти двумерному массиву)

[Lifeda92]

Сообщение от Bugrimov

В этом и загвоздка с программирование на Си/C++... ошибки по работе с памятью так скажем не всегда воспринимаются компилятором

Как же мне узнать, есть ошибки или нету?

[Bugrimov]

Запускайте!

[Lifeda92]

Все работает как часы! Но вот все ли работает так как я думаю?

Вывод:

0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15

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

[Stilet]

Но вот все ли работает так как я думаю?

Я свое мнение сказал: Мну твой код подозрительно не нравится. Не потому что он не работает или работает не верно, а потому что я его понять не смог.

[Bugrimov]

Сообщение от Stilet

Я свое мнение сказал: Мну твой код подозрительно не нравится. Не потому что он не работает или работает не верно, а потому что я его понять не смог.

Ты не одинок, я тоже его понять не могу..

[Lifeda92]

Тут тоже завтыкал (фигурные скобки тут не нужны):

for (un_int i = 0, k = 0; i < n; ++i) {
                for (un_int j = 0; j < n; ++j, ++k)
                        m[i][j] = k;
        }

for (un_int i = 0, k = 0; i < n; ++i)
                for (un_int j = 0; j < n; ++j, ++k)
                        m[i][j] = k;

[Lifeda92]

Вообщем, я думаю вот так работает мой код:

/* malloc.cpp */

#include <stdlib.h> // Местонахождение фн-ции "void *malloc(size_t size);"
#include <stdio.h> // Местонахождение фн-ции "int printf(const char *управляющая_строка, ...);"

typedef unsigned int un_int; // Новое имя целочисленного неотрицательного типа
static const un_int n = 4; // Указывает ДxШ двумерного массива

int main() {
//-----------------> Выделение памяти:

	int **m = (int**)malloc(n*sizeof(int*) + sizeof(int)*n*n); // Выделяем память массиву указателей, и еще одному - большому массиву

	for (un_int i = n-1, k = 1; i+1 < n+n; ++i, ++k)
		m[i+1-n] = (int*)&m[k*n]; // Передаем адрес ячейки указателю с интервалом "k*n"

/*      
        Схемы (n=4):

        int **m = (int**)malloc(n*sizeof(int*) + sizeof(int)*n*n); <-- Тут я создаю массив указателей (n) и еще просто 1 длинный массив (n*n)

		|*|*|*|*|&|&|&|&|&|&|&|&|&|&|&|&|&|&|&|&|
		
	for (un_int i = n-1, k = 1; i+1 < n+n; ++i, ++k)
		m[i+1-n] = (int*)&m[n*k]; // Передаем адрес ячейки указателю с интервалом "n*k"

		|*| -> |&|&|&|&|
		0 ----- 4 5 6 7

		|*| -> |&|&|&|&|
		1 ----- 8 9 10 11

		|*| -> |&|&|&|&|
		2 ----- 12 13 14 15

		|*| -> |&|&|&|&|
		3 ----- 16 17 18 19
*/
	
//-----------------> Заполнение массива числами от 0..(n-1):

	for (un_int i = 0, k = 0; i < n; ++i)
                for (un_int j = 0; j < n; ++j, ++k)
                        m[i][j] = k;

//-----------------> Вывод содержимого массива на консоль (терминал):

        for (un_int i = 0; i < n; ++i) {
                for (un_int j = 0; j < n; ++j)
                        printf("%d ", m[i][j]);
        printf("\n");
        }

//-----------------> Освобождение памяти:

	free(m);

//-----------------> Возврат 0 значения фн-ции main():

	return 0;
}

[Lifeda92]

Попытался уточнить, все ли делает программа так как я задумал.
Запустил такой код:

/* malloc.cpp */ // Имя файла

#include <stdlib.h> // Местонахождение фн-ции "void *malloc(size_t size);"
#include <stdio.h> // Местонахождение фн-ции "int printf(const char *управляющая_строка, ...);"
#include <iostream> // Местонахождение классов, фн-ций и переменных для организации ввода-вывода.

using namespace std; // открыть пространство имен библ. iostream

typedef unsigned int un_int; // Новое имя целочисленного неотрицательного типа
static const un_int len = 4, wid = 2, diff = wid - len; // Указывает ДxШ двумерного массива

void mem_test(int** &m) { // ----------> Фн-ция проверки указателей, которые указывают по нужным адресам до и после присвоения указателям нужных адресов (резул. выводится на консоль (терминал))

	for (un_int i = 0, j = wid - diff; i < len; ++i) {
		//printf("%d  ----->  ", *(&m[i]));
		cout << *(&m[i]) << "  ----->  ";

		for (un_int k = 0; k < wid; ++k, ++j) {
			switch (j) {
			case wid - diff:
				//printf("%d ", &m[len]);
				cout << &m[len] << " ";
				break;

			default:
				//printf("%d ", &m[j]);
				cout << &m[j] << " ";
			}
		}

		printf("\n");
	}

	printf("\n");
}

int main() {
//-----------------> Выделение памяти:

	int **m = (int**)malloc(len*sizeof(int*)+sizeof(int)*len*wid); // Тут я создаю массив указателей (n), и еще просто 1 длинный массив (n*n) в котором будут храниться целые числа

	mem_test(m);

	for (un_int i = len - 1, k = 1; i < len + len - 1; ++i, ++k)
		switch (i) {
		case len - 1:
			m[0] = (int*)&m[len];
			break;

		default:
		m[i + 1 - len] = (int*)&m[wid*k - diff];
		}

	mem_test(m);

/*
------------------------------------------------------------------

	Схемы (n=4):

------------------------------------------------------------------

	int **m = (int**)malloc(n*sizeof(int*) + sizeof(int)*n*n);

	|*|*|*|*|&|&|&|&|&|&|&|&|&|&|&|&|&|&|&|&|

------------------------------------------------------------------

	for (un_int i = n-1, k = 1; i+1 < n+n; ++i, ++k)
		m[i+1-n] = (int*)&m[n*k];

	|*| -> |&|&|&|&|
	0 ----- 4 5 6 7

	|*| -> |&|&|&|&|
	1 ----- 8 9 10 11

	|*| -> |&|&|&|&|
	2 ----- 12 13 14 15

	|*| -> |&|&|&|&|
	3 ----- 16 17 18 19

------------------------------------------------------------------
*/

//-----------------> Заполнение массива числами от 0..(wid*len-1):

	for (un_int i = 0, k = 0; i < len; ++i) {
		for (un_int j = 0; j < wid; ++j, ++k) {
			m[i][j] = k;
			//printf("%d ", &m[i][j]);
			cout << &m[i][j] << " ";
		}

		printf("\n");
	}

	printf("\n");

//-----------------> Вывод содержимого массива на консоль (терминал):

	for (un_int i = 0; i < len; ++i) {
		for (un_int j = 0; j < wid; ++j)
		printf("%d ", m[i][j]);
	printf("\n");
	}
			
//-----------------> Освобождение памяти:

	free(m);

//-----------------> Возврат 0 значения фн-ции main():

	return 0;
}

На выходе получил:

Это до указания указателям на нужные адреса:

0x93939393  ----->  0x9387448 0x938744c 
0x93939393  ----->  0x9387450 0x9387454 
0x93939393  ----->  0x9387458 0x938745c 
0x93939393  ----->  0x9387460 0x9387464 

Это после указания указателям на нужные адреса:

0x9387448  ----->  0x9387448 0x938744c 
0x9387450  ----->  0x9387450 0x9387454 
0x9387458  ----->  0x9387458 0x938745c 
0x9387460  ----->  0x9387460 0x9387464 

Это те адреса по которым находятся числовые значения:

0x9387448 0x938744c 
0x9387450 0x9387454 
0x9387458 0x938745c 
0x9387460 0x9387464 

Это числовые значения по адресам выше:

0 1 
2 3 
4 5 
6 7

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

(Или я что-то не то начудил И совсем не так все понимаю... )

Спасибо.

[Lifeda92]

Тут завтыкал:

static const un_int len = 4, wid = 2, diff = wid - len; // Указывает ДxШ двумерного массива

Заменил на:

static const un_int len = 4, wid = 2; // Указывает ДxШ двумерного массива
static const int diff = wid - len; // Разница