[C++] Przekazywanie dwuwymiarowej tablicy do funkcji
Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?
Zarejestruj się!

[C++] Przekazywanie dwuwymiarowej tablicy do funkcji

AutorWiadomość
Temat założony przez niniejszego użytkownika
[C++] Przekazywanie dwuwymiarowej tablicy do funkcji
» 2013-12-23 00:18:30
C/C++
#include <iostream>
#include <conio.h>
#include <ctime>
#include <stdlib.h>

using namespace std;


const int n = 3;
int tab[ n ][ n ];
int menu();
void wypelnij( int tab, int min, int max );
int wyznacznik( int tab[][ n ] );
void symetryczna();


/////////////////////////////////////////////////////////////
int main()
{
   
    int x, y, tab_1;
    wypelnij( tab_1, 1, 9 );
   
    switch( menu() )
    {
    case 1: {
           
            //  wyznacznik(tab_1);
           
           
            break;
        }
    }
   
    cout << endl << endl;
   
   
   
    getch();
    return 0;
}
/////////////////////////////////////////////////////////////
int menu()
{
   
   
    cout << " -------------------- Menu Lab 5 ---------------" << endl;
    cout << "1.Wyliczanie wyznacznika macierzy" << endl;
    cout << "2.Sprawdz czy macierz jest symetryczna " << endl;
    cout << "3.Suma wartosci komorek" << endl;
    cout << "------------------------------------------------" << endl << endl;
    int opcja;
    do {
        cout << "wybierz warunek od 1 do 3" << endl;
        cin >> opcja;
    } while( opcja < 1 || opcja > 3 );
   
}
////////////////////////////////////////////////////////
void wypelnij( int tab[][ n ], int min, int max )
{
    srand( time( 0 ) );
    for( int i = 0; i < n; i++ )
    {
        for( int j = 0; j < n; j++ )
        {
            tab[ i ][ j ] = rand() %( max - min + 1 ) + min;
            cout << tab[ i ][ j ] << " ";
        }
        cout << "\n";
    }
   
   
   
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
int wyznacznik( int tab[][ n ] )
{
    int Wyznacznik_1 =( tab[ 0 ][ 0 ] * tab[ 1 ][ 1 ] * tab[ 2 ][ 2 ] ) +( tab[ 0 ][ 1 ] * tab[ 1 ][ 2 ] * tab[ 2 ][ 0 ] ) +( tab[ 0 ][ 2 ] * tab[ 1 ][ 0 ] * tab[ 2 ][ 1 ] );
    int Wyznacznik_2 =( tab[ 2 ][ 0 ] * tab[ 1 ][ 1 ] * tab[ 0 ][ 2 ] ) +( tab[ 2 ][ 1 ] * tab[ 1 ][ 2 ] * tab[ 0 ][ 0 ] ) +( tab[ 2 ][ 2 ] * tab[ 1 ][ 0 ] * tab[ 0 ][ 1 ] );
    int Wyznacznik = Wyznacznik_1 - Wyznacznik_2;
    cout << "\nWyznacznik macierzy wynosi " << Wyznacznik << ".";
   
}
//////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////
[Error] cannot convert 'float' to 'int (*)[3]' for argument '1' to 'float wyznacznik(int (*)[3])'
Dobrze chociaż przekazuje te tablice po funkcjach, przy jednowymiarowych to ładnie śmigało, teraz coś nie chce mi pyknąć.

coś znowu przekombinowałem i funkcja która wcześniej poprawnie działała teraaz padła i pokazuje taki błąd
1.cpp:(.text+0x1e): undefined reference to `wypelnij(int, int, int)'
P-99891
» 2013-12-23 01:00:12
Generalnie tablice dwuwymiarowe w C++ to problem. Najlepszym sposobem na ich przekazywanie do funkcji jest utworzenie struktury, np.
C/C++
struct RTablica
{
    int tab[ 12 ][ 13 ];
};

void funkcja( RTablica & _tablica )
{
    _tablica.tab[ 10 ][ 11 ] = 123;
}

int main()
{
    RTablica tab;
    funkcja( tab );
   
    return 0;
}
W każdym innym przypadku jest to droga przez mękę (no chyba, że interesuje Ciebie std::vector<std::vector<int> >, ale to już inna kwestia).
P-99899
Temat założony przez niniejszego użytkownika
» 2013-12-23 01:02:14
Tego sposobu, nie mogę użyć, a czy wskaźnikami mogę to zrobić?
P-99900
» 2013-12-23 01:05:50
C/C++
#define DRUGI_WYMIAR 123

void funkcja( int _tablica[][ DRUGI_WYMIAR ] )
{
    _tablica[ 10 ][ 11 ] = 123;
}

int main()
{
    int tab[ 12 ][ DRUGI_WYMIAR ];
    funkcja( tab );
   
    return 0;
}
P-99902
» 2013-12-23 01:16:03
Na wskaźnikach:

C/C++
void rob_cos( int ** tab, int n, int m )
{
    for( int i = 0; i < n; i++ )
    for( int j = 0; j < m; j++ )
         tab[ i ][ j ] = i * j;
   
}


int main()
{
    int n = 5;
    int m = 6;
   
    int ** tab = new int *[ n ]; // tworzy "tablice" int tab[5][6]
    for( int i = 0; i < n; i++ )
         tab[ i ] = new int[ m ];
   
    rob_cos( tab, n, m );
   
    // usuwamy tablice
    for( int i = 0; i < n; i++ )
         delete[] tab[ i ];
   
    delete[] tab;
   
    return 0;
}
P-99905
» 2013-12-23 11:53:46
C/C++
void wypelnij( int tab, int min, int max );
Tak masz zadeklarowaną funkcje na podczątku

C/C++
void wypelnij( int tab[][ n ], int min, int max )
a tak faktycznie wygląda funkcja. Zła deklaracja funkcji może powodować ów błąd.

i do funkcji wysyłasz zmienną int zamiast tablicy
C/C++
int x, y, tab_1;
wypelnij( tab_1, 1, 9 );

W menu dodaj na końcu
return opcja;
i powinno działać. Aczkolwiek nie wiem, czy obliczenia są poprawne, bo się na tym nie znam :P
P-99919
Temat założony przez niniejszego użytkownika
» 2013-12-31 00:24:33
P-100727
Temat założony przez niniejszego użytkownika
» 2014-01-01 15:36:40
C/C++
#include <iostream>
#include <conio.h>
#include <ctime>
#include <stdlib.h>

using namespace std;

const int n = 3;
int ** tab;


int menu();
void wypelnij_i_pokaz( int ** tab, int min, int max );

int wyznacznik( int ** tab );
bool symetryczna( int ** tab, int n );
int suma_komorek( int ** tab, int n );


////////////////////////////////////////////////////////////////////////////////////
int main()
{
   
   
    switch( menu() )
    {
    case 1: {
            system( "CLS" );
            cout << "Macierz 3x3" << endl;
            wypelnij_i_pokaz( tab, 1, 9 );
            wyznacznik( tab );
           
            break;
        }
    case 2: {
            wypelnij_i_pokaz( tab, 1, 9 );
            if( symetryczna( tab, n ) )
                 cout << "Tablica jest symetryczna" << endl;
            else
                 cout << "tablica jest niesymetryczna" << endl;
           
            break;
        }
    case 3: {
            wypelnij_i_pokaz( tab, 1, 9 );
            suma_komorek( tab, n );
            break;
        }
    }
    system( "pause" );
}
/////////////////////////////////////////////////////////////////////////////////////
int menu() {
    int opcja;
   
    do {
       
        cout << " ============ Menu Lab 5 ============" << endl;
        cout << "1.Wyliczanie wyznacznika macierzy" << endl;
        cout << "2.Sprawdz czy macierz jest symetryczna " << endl;
        cout << "3.Suma wartosci komorek" << endl;
        cout << "=======================================" << endl << endl;
        cout << "wybierz warunek od 1 do 3" << endl;
        cin >> opcja;
    }
    while( opcja < 1 || opcja > 3 );
   
    return opcja;
}
////////////////////////////////////////////////////////////////////////////////////
void wypelnij_i_pokaz( int ** tab, int min, int max )
{
    tab = new int *[ n ]; //<-------- PIERWSZY!
    srand( time( 0 ) );
    for( int i = 0; i < n; i++ )
    {
        tab[ i ] = new int[ n ]; //<--------------- ODWOŁANIE DO DRUGIEGO WYMIARU !
        for( int j = 0; j < n; j++ )
        {
            tab[ i ][ j ] = rand() %( max - min + 1 ) + min;
            cout << tab[ i ][ j ] << " ";
        }
       
        cout << "\n";
    }
}
////////////////////////////////////////////////////////////////
int wyznacznik( int ** tab )
{
    int Wyznacznik;
   
    tab = new int *[ n ];
    for( int i = 0; i < n; i++ )
    {
        tab[ i ] = new int[ n ];
        for( int j = 0; j < n; j++ )
        {
           
            int Wyznacznik_1 =( tab[ 0 ][ 0 ] * tab[ 1 ][ 1 ] * tab[ 2 ][ 2 ] ) +( tab[ 0 ][ 1 ] * tab[ 1 ][ 2 ] * tab[ 2 ][ 0 ] ) +( tab[ 0 ][ 2 ] * tab[ 1 ][ 0 ] * tab[ 2 ][ 1 ] );
            int Wyznacznik_2 =( tab[ 2 ][ 0 ] * tab[ 1 ][ 1 ] * tab[ 0 ][ 2 ] ) +( tab[ 2 ][ 1 ] * tab[ 1 ][ 2 ] * tab[ 0 ][ 0 ] ) +( tab[ 2 ][ 2 ] * tab[ 1 ][ 0 ] * tab[ 0 ][ 1 ] );
            cout << Wyznacznik_1 << endl;
            cout << Wyznacznik_2 << endl;
            Wyznacznik = Wyznacznik_1 - Wyznacznik_2;
        }
    }
    cout << "\nWyznacznik macierzy wynosi " << Wyznacznik << ".";
    return Wyznacznik;
}
/////////////////////////////////////////////////////////////////////////////////////
bool symetryczna( int ** tab, int n )
{
    tab = new int *[ n ];
    for( int i = 0; i < n; i++ )
    {
        tab[ i ] = new int[ n ];
        for( int j = 0; j < n; j++ )
        {
            if( tab[ i ][ j ] != tab[ j ][ i ] )
            {
                return false;
            }
        }
    }
    return true;
}
//////////////////////////////////////////////////////////////////////////////
int suma_komorek( int ** tab, int n )
{
   
    int suma = 0;
    tab = new int *[ n ];
    for( int i = 0; i < n; i++ )
    {
        tab[ i ] = new int[ n ];
        for( int j = 0; j < n; j++ )
        {
            if(( i + j ) % 2 == 0 )
            {
                suma = suma + tab[ i ][ j ];
               
            }
        }
       
    }
    cout << "suma wynosi " << suma << endl;
    return suma;
}
W tej sytuacji, program mi pokazuje że wyznacznik jest 0, nie widzi macierzy z poprzedniej funkcji?[/i]
P-100844
« 1 » 2
 Strona 1 z 2Następna strona