[C++] Klasa jako dynamiczna dwuwymiarowa tablica
Logowanie
Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?
Zapomniałem hasła
» Forum » Programowanie » [C, C++] Szukam pomocy

[C++] Klasa jako dynamiczna dwuwymiarowa tablica

Ostatnio zmodyfikowano 2013-07-19 13:14
Autor Wiadomość
Bimbol
Temat założony przez niniejszego użytkownika
[C++] Klasa jako dynamiczna dwuwymiarowa tablica
» 2013-07-18 17:52:37
Witam,
Napisałem klase, która ma służyć jak tablica dwuwymiarowa.

Wszystko działa dobrze, oprócz metody
SetSize( unsigned Size1, unsigned Size2 )

main.cpp
C/C++
#include "array.h"

using namespace std;

int main()
{
    CArrayDouble Tab( 1, 10 );
    Tab.SetSize( 2, 15 );
    cout << "Size: " << Tab.GetSize1() << " " << Tab.GetSize2() << endl;
    for( unsigned i = 0; i < Tab.GetSize1(); ++i )
    for( unsigned j = 0; j < Tab.GetSize2(); ++j )
         Tab.SetValue( i, j, i + j );
   
    for( unsigned i = 0; i < Tab.GetSize1(); ++i )
    for( unsigned j = 0; j < Tab.GetSize2(); ++j )
         cout << Tab.ShowValue( i, j ) << endl;
   
    return 0;
}

array.h:
C/C++
#ifndef ARRAY_H_INCLUDED
#define ARRAY_H_INCLUDED

#include <iostream>
#include <memory.h>

class CArrayDouble
{
    static const unsigned DEFAULT_SIZE = 1;
   
private:
    int ** nTable;
    unsigned m_Size1;
    unsigned m_Size2;
public:
    CArrayDouble()
    {
        nTable = new int *[ DEFAULT_SIZE ];
        for( unsigned i = 0; i < DEFAULT_SIZE; ++i )
             nTable[ i ] = new int[ DEFAULT_SIZE ];
       
    }
   
    CArrayDouble( unsigned Size1, unsigned Size2 )
        : m_Size1( Size1 )
        , m_Size2( Size2 )
    {
        nTable = new int *[ Size1 ];
        for( unsigned i = 0; i < Size1; ++i )
             nTable[ i ] = new int[ Size2 ];
       
    }
   
    ~CArrayDouble()
    {
        for( unsigned i = 0; i < m_Size1; ++i )
             delete[] nTable[ i ];
       
        delete[] nTable;
    }
   
    //metody
    unsigned GetSize1() const { return m_Size1; }
    unsigned GetSize2() const { return m_Size2; }
    unsigned SetValue( unsigned index1, unsigned index2, int value )
    {
        if( index1 >= m_Size1 || index2 >= m_Size2 ) return false;
       
        nTable[ index1 ][ index2 ] = value;
    }
   
    int ShowValue( unsigned index1, unsigned index2 )
    {
        if( index1 >= m_Size1 || index2 >= m_Size2 ) return false;
       
        return nTable[ index1 ][ index2 ];
    }
   
    bool SetSize( unsigned Size1, unsigned Size2 )
    {
        int ** newTable = new int *[ Size1 ];
       
        for( unsigned i = 0; i < Size1; ++i )
             newTable[ i ] = new int[ Size2 ];
        // if dodac niech sprawdza czy jest mniejsze czy nie
        if( Size2 >= m_Size2 )
        for( unsigned i = 0; i < m_Size1; ++i )
        {
            memcpy( newTable[ i ], nTable[ i ], m_Size2 * sizeof( int ) );
            delete[] nTable[ i ];
        }
        else
        for( unsigned i = 0; i < m_Size1; ++i )
        {
            memcpy( newTable[ i ], nTable[ i ], Size2 * sizeof( int ) );
            delete[] nTable[ i ];
        }
        if( Size1 >= m_Size1 )
        {
            memcpy( newTable, nTable, m_Size1 * sizeof( int ) );
            delete[] nTable;
        }
        else
        {
            memcpy( newTable, nTable, Size1 * sizeof( int ) );
            delete[] nTable;
        }
       
        for( unsigned i = 0; i < Size1; ++i )
             nTable[ i ] = newTable[ i ];
       
        nTable = newTable;
       
        m_Size1 = Size1;
        m_Size2 = Size2;
       
        // zwracamy pozytywny rezultat
        return true;
    }
};


#endif // ARRAY_H_INCLUDED

Używałem debugera, jednak wciąż nie wiem co robię źle. Prawdopodobnie nie umiejętnie posługuję się funkcją
void * memcpy( void * dest, const void * src, size_t count )

Z góry dziękuję za pomoc, wskazówki, rady.
P-88205
RazzorFlame
» 2013-07-18 22:05:44
Spróbuj może coś w tym stylu:
C/C++
void CArrayDouble::SetSize( int x, int y )
{
    int ** newTable;
    newTable = new int *[ x ];
    for( int i = 0; i < x; i++ )
    {
        newTable[ i ] = new int[ y ];
    }
    //wstepna inicjalizacja na 0
   
    for( int xx = 0; xx < x; xx++ )
    {
        if( xx > SizeX ) break;
       
        for( int yy = 0; yy < y; yy++ )
        {
            if( yy > SizeY ) break;
           
            newTable[ xx ][ yy ] = 0;
        }
    }
   
    //kopiowanie wartosci ze starej tablicy do nowej
   
    for( int xx = 0; xx < x; xx++ )
    {
        if( xx > SizeX ) break;
       
        for( int yy = 0; yy < y; yy++ )
        {
            if( yy > SizeY ) break;
           
            newTable[ xx ][ yy ] = oldTable[ xx ][ yy ];
        }
    }
   
    //ustawianie wielkosci tablicy (symboliczne SizeX i SizeY (podmien to na twoje wymiary))
    SizeX = x;
    SizeY = y;
   
}
PS. Sory ze gotowcem ale nie potrafiłem wytłumaczyć.
P-88242
Bimbol
Temat założony przez niniejszego użytkownika
» 2013-07-19 13:14:33
Wolę użyć memcpy. W tym przykładzie również brakuje zwalniania pamięci.

Czy ktoś ma jakieś inne sugestie?

Trochę się z tym bawiłem, ale wciąż nic. Ciągle sypie się w tym samym momencie.

main.cpp:
C/C++
#include "array.h"

using namespace std;

int main()
{
    CArrayDouble Tab( 2, 2 );
    Tab.SetSize( 6, 6 );
    return 0;
}

array.h:
C/C++
#ifndef ARRAY_H_INCLUDED
#define ARRAY_H_INCLUDED

#include <iostream>
#include <memory.h>
#include <conio.h>

class CArrayDouble
{
private:
    int ** nTable;
    unsigned m_Size1;
    unsigned m_Size2;
public:
    CArrayDouble( unsigned Size1, unsigned Size2 )
        : m_Size1( Size1 )
        , m_Size2( Size2 )
    {
        nTable = new int *[ Size1 ];
        for( unsigned i = 0; i < Size1; ++i )
             nTable[ i ] = new int[ Size2 ];
       
    }
    // Dekonstruktor
    ~CArrayDouble()
    {
        for( unsigned i = 0; i < m_Size1; ++i )
             delete[] nTable[ i ];
       
        delete[] nTable; // Tutaj wyskakuje Segmentation Faul
    }
   
    // Metody
    bool SetSize( unsigned Size1, unsigned Size2 )
    {
       
        if( Size1 <= m_Size1 || Size2 <= m_Size2 ) return false;
       
        int ** newTable = new int *[ Size1 ];
       
        for( unsigned i = 0; i < Size1; ++i )
             newTable[ i ] = new int[ Size2 ];
       
        // Kopiujemy zawartosc
        for( unsigned i = 0; i < m_Size1; ++i )
             memcpy( newTable[ i ], nTable[ i ], m_Size2 * sizeof( int ) );
       
        memcpy( newTable, nTable, m_Size1 * sizeof( int ) );
       
        // Przypisujemy do tablicy
       
        nTable = newTable;
       
        m_Size1 = Size1;
        m_Size2 = Size2;
       
        // Kasujemy tymczasow¹ tablice
        for( unsigned i = 0; i < Size1; ++i )
             delete[] newTable[ i ];
       
        delete[] newTable;
       
        return true;
    }
};

#endif // ARRAY_H_INCLUDED

W dekonstruktorze się sypie, dokładniej
delete[] nTable;

Wie ktoś w czym problem?

EDIT.

Poradziłem sobie.
P-88294
« 1 »
  Strona 1 z 1  
» Forum » Programowanie » [C, C++] Szukam pomocy
© Wszelkie prawa zastrzeżone 2005-2024