Builder.cz - Informacni server o programovani

Levellak Napsal:
-------------------------------------------------------
> Ahoj,
> nevite nekdo jestli jde a jak reallocovat dvou
> rozmerne pole ?
> Dekuji


jde:
1. alokovat nové pole
2. obsah původního pole zkopírovat do nového
3. delete starého pole

Použití vektoru by dalo méně práce.

hu

Levellak Napsal: ------------------------------------------------------- > Ahoj, > nevite nekdo jestli jde a jak reallocovat dvou > rozmerne pole ? > Dekuji jde: 1. alokovat nové pole 2. obsah původního pole zkopírovat do nového 3. delete starého pole Použití vektoru by dalo méně práce. hu

Citovat příspěvek

Ahoj,
nevite nekdo jestli jde a jak reallocovat dvou rozmerne pole ?
Dekuji

Ahoj, nevite nekdo jestli jde a jak reallocovat dvou rozmerne pole ? Dekuji

Citovat příspěvek

//------------------------------------------------------------------------------
// přímá inicializace při deklaraci pole:
//------------------------------------------------------------------------------
// 1D pole:
int arr1[4] = {1, 2, 3, 4};
// 2D pole:
int arr2[3][5] = //3 - vnejsi pole; 5 - vnitrni pole
{
{11, 12, 13, 14, 15},
{21, 22, 23, 24, 25},
{31, 32, 33, 34, 35}
};

// 3D pole:
int arr3[3][5][2] = //3 - vnejsi pole; 5 - stredni pole; 2 - vnitrni pole
{
{{1, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 5}},
{{2, 1}, {2, 2}, {2, 3}, {2, 4}, {2, 5}},
{{3, 1}, {3, 2}, {3, 3}, {3, 4}, {3, 5}}
};
//------------------------------------------------------------------------------
//inicializace pomoci cyklu:
//------------------------------------------------------------------------------
// 1D pole:
int arr1c[4];
int inc = 0;
for(int i = 0; i < 4; i++)
arr1c[i] == inc++;
// 2D pole:
int arr2c[3][5];
inc = 1;
for(int i = 0;i < 3; i++) //inicializace
for(int j = 0; j < 5; j++)
arr2c[i][j] = inc++;
cout << "Inicializace 2D pole:\n\nDoslo k " << inc << " vlozenim."
<< "\nCele pole vypada takto:\n";
for(int i = 0;i < 3; i++)
{
for(int j = 0;j < 5; j++)
{
cout << arr2c[i][j] << "\t";
}
cout << endl;
}
cin.get();
// 3D pole:
int arr3c[3][5][2];
inc = 0;
for(int i = 0; i < 3; i++) //inicializace
for(int j = 0; j < 5; j++)
for(int k = 0; k < 2; k++)
arr3c[i][j][k] = inc++;
cout << endl << "Inicializace 3D pole:\n\nDoslo k " << inc << " vlozenim."
<< "\nCele pole vypada takto:\n";
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 5; j++)
{
for(int k = 0; k < 2; k++)
{
cout << arr3c[i][j][k];
if(k == 0)
cout << ",";
}
cout << "\t";
}
cout << endl;
}
cin.get();
//------------------------------------------------------------------------------
// dynamicke vytvoreni vicerozmernych poli:
//------------------------------------------------------------------------------
// 1D pole:
int *arr1d = new int[3];
inc = 0;
for(int i = 0; i < 3; i++) //inicializace
arr1d[i] = inc++;
cout << "\n-------------------------------------------\n"
<< "Dynamicka alokace vice rozmernych poli:\n";
cout << "Inicializace 1D dyn. pole:\n\nDoslo k " << inc << " vlozenim.\n"
<< "Cele pole vypada takto:\n";
for(int i = 0; i < 3; i++)
cout << arr1d[i] << "\t";
cout << endl;
delete [] arr1d; //destrukce pameti
cin.get();
// 2D pole:
int **arr2d = new int*[3]; //arr2d je ukazatel na ukazatel na int
//a prirazujeme mu promennou typu ukazatel na int (int*)
for(int i = 0;i < 3; i++)
arr2d[i] = new int[5]; //vsem prvkum pole priradime promennou typu int

//promenna arr2d je typu int**
//promenna arr2d[i] je typu int*
//promenna arr2d[i][j] je typu int


inc = 1;
for(int i = 0; i < 3; i++) //inicializace
for(int j = 0; j < 5; j++)
arr2d[i][j] = inc++;
cout << "\nInicializace 2D dyn. pole:\n\nDoslo k " << inc << " vlozenim.\n"
<< "Cele pole vypada takto:\n";
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 5; j++)
cout << arr2d[i][j] << "\t";
cout << endl;
}
for(int i = 0;i < 3; i++) //destrukce pameti
delete[] arr2d[i]; //nejprve destrukce pameti pro "vnitrni" ukazatele
delete[] *arr2d; //a nakonec destrukce ukazatel na pole
cin.get();
// 3D pole:
int ***arr3d = new int**[3]; //vytvorim pole promennych typu
// ukazatel na ukazatel na ukazatel na int
for(int i = 0; i < 3; i++)
arr3d[i] = new int*[5]; //promenna arr3d je typu int***
for(int i = 0; i < 3; i++) //promenna arr3d[i] je typu int**
for(int j = 0; j < 5; j++) //promenna arr3d[i][j] je typu int*
arr3d[i][j] = new int[2]; //promenna arr3d[i][j][k]je typu int
inc = 1;
for(int i = 0; i < 3; i++) //inicializace
for(int j = 0; j < 5; j++)
for(int k = 0; k < 2; k++)
arr3d[i][j][k] = inc++;
cout << "\nInicializace 3D dyn. pole:\n\nDoslo k " << inc << " vlozenim.\n"
<< "Cele pole vypada takto:\n\n";
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 5; j++)
{
for(int k = 0; k < 2; k++)
{
cout << arr3d[i][j][k];
if(k == 0)
cout << ",";
}
cout << "\t";
}
cout << endl;
}
for(int i = 0; i < 3; i++) //destrukce pameti
for(int j = 0; j < 5; j++)
delete[] arr3d[i][j]; //zruseni promenne typu int
for(int i = 0; i < 3; i++)
delete[] arr3d[i]; //zruseni promenne typu int*
delete[] arr3d; //zruseni promenne typu int**
cin.get();
return 0;

//------------------------------------------------------------------------------ // přímá inicializace při deklaraci pole: //------------------------------------------------------------------------------ // 1D pole: int arr1[4] = {1, 2, 3, 4}; // 2D pole: int arr2[3][5] = //3 - vnejsi pole; 5 - vnitrni pole { {11, 12, 13, 14, 15}, {21, 22, 23, 24, 25}, {31, 32, 33, 34, 35} }; // 3D pole: int arr3[3][5][2] = //3 - vnejsi pole; 5 - stredni pole; 2 - vnitrni pole { {{1, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 5}}, {{2, 1}, {2, 2}, {2, 3}, {2, 4}, {2, 5}}, {{3, 1}, {3, 2}, {3, 3}, {3, 4}, {3, 5}} }; //------------------------------------------------------------------------------ //inicializace pomoci cyklu: //------------------------------------------------------------------------------ // 1D pole: int arr1c[4]; int inc = 0; for(int i = 0; i < 4; i++) arr1c[i] == inc++; // 2D pole: int arr2c[3][5]; inc = 1; for(int i = 0;i < 3; i++) //inicializace for(int j = 0; j < 5; j++) arr2c[i][j] = inc++; cout << "Inicializace 2D pole:\n\nDoslo k " << inc << " vlozenim." << "\nCele pole vypada takto:\n"; for(int i = 0;i < 3; i++) { for(int j = 0;j < 5; j++) { cout << arr2c[i][j] << "\t"; } cout << endl; } cin.get(); // 3D pole: int arr3c[3][5][2]; inc = 0; for(int i = 0; i < 3; i++) //inicializace for(int j = 0; j < 5; j++) for(int k = 0; k < 2; k++) arr3c[i][j][k] = inc++; cout << endl << "Inicializace 3D pole:\n\nDoslo k " << inc << " vlozenim." << "\nCele pole vypada takto:\n"; for(int i = 0; i < 3; i++) { for(int j = 0; j < 5; j++) { for(int k = 0; k < 2; k++) { cout << arr3c[i][j][k]; if(k == 0) cout << ","; } cout << "\t"; } cout << endl; } cin.get(); //------------------------------------------------------------------------------ // dynamicke vytvoreni vicerozmernych poli: //------------------------------------------------------------------------------ // 1D pole: int *arr1d = new int[3]; inc = 0; for(int i = 0; i < 3; i++) //inicializace arr1d[i] = inc++; cout << "\n-------------------------------------------\n" << "Dynamicka alokace vice rozmernych poli:\n"; cout << "Inicializace 1D dyn. pole:\n\nDoslo k " << inc << " vlozenim.\n" << "Cele pole vypada takto:\n"; for(int i = 0; i < 3; i++) cout << arr1d[i] << "\t"; cout << endl; delete [] arr1d; //destrukce pameti cin.get(); // 2D pole: int **arr2d = new int*[3]; //arr2d je ukazatel na ukazatel na int //a prirazujeme mu promennou typu ukazatel na int (int*) for(int i = 0;i < 3; i++) arr2d[i] = new int[5]; //vsem prvkum pole priradime promennou typu int //promenna arr2d je typu int** //promenna arr2d[i] je typu int* //promenna arr2d[i][j] je typu int inc = 1; for(int i = 0; i < 3; i++) //inicializace for(int j = 0; j < 5; j++) arr2d[i][j] = inc++; cout << "\nInicializace 2D dyn. pole:\n\nDoslo k " << inc << " vlozenim.\n" << "Cele pole vypada takto:\n"; for(int i = 0; i < 3; i++) { for(int j = 0; j < 5; j++) cout << arr2d[i][j] << "\t"; cout << endl; } for(int i = 0;i < 3; i++) //destrukce pameti delete[] arr2d[i]; //nejprve destrukce pameti pro "vnitrni" ukazatele delete[] *arr2d; //a nakonec destrukce ukazatel na pole cin.get(); // 3D pole: int ***arr3d = new int**[3]; //vytvorim pole promennych typu // ukazatel na ukazatel na ukazatel na int for(int i = 0; i < 3; i++) arr3d[i] = new int*[5]; //promenna arr3d je typu int*** for(int i = 0; i < 3; i++) //promenna arr3d[i] je typu int** for(int j = 0; j < 5; j++) //promenna arr3d[i][j] je typu int* arr3d[i][j] = new int[2]; //promenna arr3d[i][j][k]je typu int inc = 1; for(int i = 0; i < 3; i++) //inicializace for(int j = 0; j < 5; j++) for(int k = 0; k < 2; k++) arr3d[i][j][k] = inc++; cout << "\nInicializace 3D dyn. pole:\n\nDoslo k " << inc << " vlozenim.\n" << "Cele pole vypada takto:\n\n"; for(int i = 0; i < 3; i++) { for(int j = 0; j < 5; j++) { for(int k = 0; k < 2; k++) { cout << arr3d[i][j][k]; if(k == 0) cout << ","; } cout << "\t"; } cout << endl; } for(int i = 0; i < 3; i++) //destrukce pameti for(int j = 0; j < 5; j++) delete[] arr3d[i][j]; //zruseni promenne typu int for(int i = 0; i < 3; i++) delete[] arr3d[i]; //zruseni promenne typu int* delete[] arr3d; //zruseni promenne typu int** cin.get(); return 0;

Citovat příspěvek

Tomas, tvoja oblubena tema, viacrozmerne pole. :)

Prednedavnom som pozeral kniznicu boost a tam sa nachadzaju sablony (The Boost Multidimensional Array Library), ktore celu problematiku riesia velmi efektivne. Podla dokumentacie je ulozenie dat v tvare, kompatibilnom so statickymi polami c++ pripadne fortranu. Neskusal som to sice skompilovat v builderi, ale predpokladam, ze by to asi nemal byt problem.

[code]
#include "boost/multi_array.hpp"
#include

int
main () {
// Create a 3D array that is 3 x 4 x 2
typedef boost::multi_array array_type;
typedef array_type::index index;
array_type A(boost::extents[3][4][2]);

// Assign values to the elements
int values = 0;
for(index i = 0; i != 3; ++i)
for(index j = 0; j != 4; ++j)
for(index k = 0; k != 2; ++k)
A[i][j][k] = values++;

// Verify values
int verify = 0;
for(index i = 0; i != 3; ++i)
for(index j = 0; j != 4; ++j)
for(index k = 0; k != 2; ++k)
assert(A[i][j][k] == verify++);

return 0;
}

[/code]

Tomas, tvoja oblubena tema, viacrozmerne pole. :) Prednedavnom som pozeral kniznicu boost a tam sa nachadzaju sablony (The Boost Multidimensional Array Library), ktore celu problematiku riesia velmi efektivne. Podla dokumentacie je ulozenie dat v tvare, kompatibilnom so statickymi polami c++ pripadne fortranu. Neskusal som to sice skompilovat v builderi, ale predpokladam, ze by to asi nemal byt problem. [code] #include "boost/multi_array.hpp" #include int main () { // Create a 3D array that is 3 x 4 x 2 typedef boost::multi_array array_type; typedef array_type::index index; array_type A(boost::extents[3][4][2]); // Assign values to the elements int values = 0; for(index i = 0; i != 3; ++i) for(index j = 0; j != 4; ++j) for(index k = 0; k != 2; ++k) A[i][j][k] = values++; // Verify values int verify = 0; for(index i = 0; i != 3; ++i) for(index j = 0; j != 4; ++j) for(index k = 0; k != 2; ++k) assert(A[i][j][k] == verify++); return 0; } [/code]

Citovat příspěvek

Musis to alokovat po rade,
mat=new int*[x];
for(i=0;i
a pak v obracenem gardu deletovat.

Vrele bych ale misto toho doporucil vector >:


Dvourozmerny vector stringu [url]http://forum.builder.cz/read.php?123,1295747,1295920#msg-1295920[/url]

Class s dvema rozmery
[url]http://forum.builder.cz/read.php?123,1281548,1282875#msg-1282875[/url]

Alokace pole 9*9 s vectory
[url]http://forum.builder.cz/read.php?123,1281548,1282875#msg-1282875[/url]

Zdravim
TC

Musis to alokovat po rade, mat=new int*[x]; for(i=0;i >: Dvourozmerny vector stringu [url]http://forum.builder.cz/read.php?123,1295747,1295920#msg-1295920[/url] Class s dvema rozmery [url]http://forum.builder.cz/read.php?123,1281548,1282875#msg-1282875[/url] Alokace pole 9*9 s vectory [url]http://forum.builder.cz/read.php?123,1281548,1282875#msg-1282875[/url] Zdravim TC

Citovat příspěvek

Potřeboval bych poradit jak v c++ alokovat dvourozměrné pole přez funkci
mat=(int**) new int [x][y]; takhle to asi nejde

:S

Děkuji

Potřeboval bych poradit jak v c++ alokovat dvourozměrné pole přez funkci mat=(int**) new int [x][y]; takhle to asi nejde :S Děkuji

Citovat příspěvek