Tabellen auslesen

hallo,

ich muss eine Tabelle auslesen. in welchem Datentyp ist es günstig, eine solche Tabelle zu speichern...
Ich dachte an einen map<char,map<char,int> > doch komm ich damit momentan noch nicht klar!

Die Tabellen sehen ungefähr so aus und ich muss auf die einzelnen Werte zugreifen (z.B Q|R => 1). Jeder Buchstabe kommt dabei einmal in der hozizontalen und einmal in der vertikalen vor!

A R N D C Q E G H I
A 4 -1 -2 -2 0 -1 -1 0 -2 -1
R -1 5 0 -2 -3 1 0 -2 0 -3

thx4help

Ich weiss zwar nicht genau was du damit tun willst, aber wie wärs denn mit:
map<pair<char, char>, int>

wie kann ich beim einlesen von dateien(hier tabellen) ein end-of-line abfragen. Ich "bräuchte" eine Abfrage ähnlich wie eof => end-of-file...

^^

thx

joomoo

K.A. schrieb:

wie kann ich beim einlesen von dateien(hier tabellen) ein end-of-line abfragen. Ich "bräuchte" eine Abfrage ähnlich wie eof => end-of-file...

^^

thx

getline()
oder einfach auf das "\n" zeichen prüfen, denn das ist das zeichen für zeilenumbruch.

mfg.

Hallo,
mit Hilfe unten angegebenen Funktion, werden Daten aus Excel eingelesen.
Ich schaffe es leider nicht die zu verarbeiten. Kann mir jemand Bitte helfen.

void load ( void )
{
SQLHENV hEnv = 0;
SQLHDBC hDBC = 0;
SQLHSTMT hStmt = 0;
SQLCHAR szConnStr[255];
SQLCHAR szStmt[255];
SQLCHAR szSem[255];
SWORD cbConnStr;
RETCODE rc;
SDWORD sdwSMLen;
SDWORD sdwDZLen;
SDWORD sdwBZLen;
SDWORD sdwVLen;
SDWORD sdwULen;
int i;
char szResult[1000];

SQLTRY("SQLAllocEnv", SQLAllocEnv(&hEnv))
SQLTRY("SQLAllocConnect", SQLAllocConnect(hEnv, &hDBC))
SQLTRY("SQLDriverConnect", SQLDriverConnect(hDBC, NULL, CONNSTR, CONNLEN, szConnStr, sizeof(szConnStr), &cbConnStr, SQL_DRIVER_NOPROMPT))
SQLTRY("SQLAllocStmt", SQLAllocStmt(hDBC, &hStmt))

sprintf(szStmt, "SELECT * FROM [Tabelle1$]");
SQLTRY("SQLPrepare", SQLPrepare(hStmt, szStmt, strlen(szStmt)))

SQLTRY("SQLBindCol", SQLBindCol(hStmt, 1, SQL_C_CHAR, (PTR)szSem, sizeof(szSemester), &sdwSMLen))

SQLTRY("SQLExecute", SQLExecute(hStmt))

for (i = 1; (rc = SQLFetch(hStmt)) == SQL_SUCCESS; i++)
{

printf("#%d\t %s\n", i, szSem );

}

if (rc != SQL_NO_DATA_FOUND)
{
SQLTRY("SQLFetch", rc)
}

printf("Operation war erfolgreich.\n");

if (hStmt) SQLFreeStmt(hStmt, SQL_CLOSE);
if (hDBC) SQLDisconnect(hDBC);
if (hDBC) SQLFreeConnect(hDBC);
if (hEnv) SQLFreeEnv(hEnv);
}

mfg Gast

Werner Salomon

K.A. schrieb:

ich muss eine Tabelle auslesen. in welchem Datentyp ist es günstig, eine solche Tabelle zu speichern...
Ich dachte an einen map<char,map<char,int> > doch komm ich damit momentan noch nicht klar!

am besten Du machst Dir eine eigene Klasse mit einer map<pair<char, char>, int> im Bauch, wie schon von Redhead vorgeschlagen.
Eine Klasse - ich nenne sie mal Tabelle - sollte einen istream-operator haben und vielleicht gleich eine Methode um einfach mit zwei Zeichen an die Werte der Tabelle ranzukommen.

#include <iostream>
#include <map>

class Tabelle
{
public:
    Tabelle() : m_tab() {}
    int& operator()( char c1, char c2 );
    friend std::istream& operator>>( std::istream& in, Tabelle& tab_ );
private:
    std::map< std::pair< char, char >, int > m_tab;
};

Die Implementierung sähe dann so aus

#include <iterator>
#include <string>
#include <sstream>
#include <vector>

    int& Tabelle::operator()( char c1, char c2 )
    {
        return m_tab[ std::make_pair( c1, c2 ) ];
    }

    std::istream& operator>>( std::istream& in, Tabelle& tab_ )
    {
        Tabelle tab;
        std::vector< char > lbl2;   // Labels der Horizontalen (Kopfzeile)
        {   // --   Kopfzeile einlesen
            std::string zl1str;
            if( !std::getline( in, zl1str ) ) 
                return in;
            std::stringstream zl1( zl1str );
            std::copy( std::istream_iterator< char >( zl1 ), std::istream_iterator< char >(),
                std::back_inserter( lbl2 ) );
        }
        for( int zl=0; zl<lbl2.size(); ++zl )
        {
            char lbl1;
            if( (in >> lbl1).fail() )   // ersten Buchstaben der Zeile lesen
                return in;
            for( int sp=0; sp<lbl2.size(); ++sp )
            {
                int zahl;
                if( (in >> zahl).fail() )   // Zahl in der Tabelle einlesen ..
                    return in;
                tab.m_tab.insert( std::make_pair( // .. und speichern
                    std::make_pair( lbl1, lbl2[sp] ),   // <- Key
                    zahl ) );                           // <- Value
            }
        }
        tab.m_tab.swap( tab_.m_tab );   // alles Ok, dann Tabelle übernehmen
        return in;
    }

und die Anwendung wird ganz einfach

#include <fstream>
#include <iostream>

int main()
{
    using namespace std;
    Tabelle tab;
    ifstream file("input.txt");
    if( file >> tab )
    {
        cout << "Zahl an Position(I,H) ist " << tab( 'I', 'H' ) << endl;
        cout << "Zahl an Position(N,G) ist " << tab( 'N', 'G' ) << endl;
    }
    return 0;
}

Gruß
Werner