Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (WinAPI, Konsole) » ------------------mulitmap -----------------------

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 < [ 2 ] [ 3 ]
000
25.07.2013, 14:48 Uhr
~YumiFerrari
Gast


Hallo zusammen,
ich brauche dringend Hilfe und hoffe, dass jemand weiter helfen kann.
Eine CSV Datei soll eingelesen werden (bestimmte Spalten) und das soll in eine Map gespeichert werden. Die Spalten sind mit verschiendenen Inhalten gefüllt.
Die Funktion soll so sein, dass man den Namen eingibt und dafür die Adresse als Output erhält. Die Adresse ist ein String, was später auch zerlegt werden muss und in eine Struktur geladen werden soll (ODK Struct um genau zu sein).
Ich habe das erst mal mit einer Map versucht nur das Problem ist, dass die doppelten Namen überschrieben werden. Daher die Multimap. Leider klappt das noch nicht, weil ich nicht genau weiß, wie ich das umschreiben kann von einer Map zu einer Multimap. Dazu kommt noch, dass ich als Ausgabe alle möglichen Treffer erhalten werde, wobei ich ja nur ein bestimmtes Ergebnis haben möchte Jetzt kommt das blöde.....Die Namen befinden sich alle in einem Bestimmten Level. Und um das genaue Ergebnis zu bekommen, soll man den genauen Namenpfad eingeben....Das ist dann wie eine Baumstruktur aufgebaut..... Dann geht man von Knotenpunkt zu Knotenpunkt durch und schreibt die Namen auf. Diese sollen dann mit einem Punkt getrennt werden. Ich hab mir so viele Gedanken gemacht, wie man die Lösung hinbekommt, aber kann das leider nicht umsetzen......
Kann mir einer helfen?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
25.07.2013, 23:08 Uhr
Hans
Library Walker
(Operator)


Hi,
wenn Du auch Deinen Code zeigen würdest, inclusiv einer Erklärung, wo es genau hakt und warum Du das an der Stelle nicht verstehst, dann kann Dir auch geholfen werden. Ansonsten sieht es schlecht aus.

Hans
--
Man muss nicht alles wissen, aber man sollte wissen, wo es steht. Zum Beispiel hier: Nachdenkseiten oder Infoportal Globalisierung.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
26.07.2013, 10:37 Uhr
YumiFerrari



Hallo,

ich hab nur was zu map, was aber nicht richtig ist so eine Datei einzulesen. Daher habe ich das nicht mit rein gestellt.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
26.07.2013, 18:32 Uhr
Hans
Library Walker
(Operator)


Hi,

zwei Sachen: Erstens brauchst du für eine genauere Erklärung des Problems keinen neuen Thread anzufangen.
Zweitens solltest Du überlegen was du genau willst, d.h. womit du arbeiten willst. Willst Du 'ne Baumstruktur mittels map/multimap erzeugen? Oder mit 'ner parallelen Baumstruktur arbeiten?

--- etwas später ---
Nach dem, was ich jetzt mal kurz gelesen habe, arbeitet map intern schon mit einer Baumstruktur, also ist es Unfug, zu versuchen, eine weitere Baumstruktur parallel zu nutzen.
Stattdessen solltest Du Dir überlegen, ob die Sortierung anhand der Levels wirklich Sinnvoll ist. Denn je nach dem, was für ein Level Du hast, sind da viele Elemente, z.B. Kuchensorten drin, oder wenige wie die Menge der Sahne dazu.

--- noch später ---
Da map mit Schlüsselzuordnungen arbeitet, kann die Idee mit dem Level als Schlüssel auch nicht funktionieren. Du brauchst für jedes Element, das Du in der map speichern willst, einen eignen Schlüssel anhand dessen es eindeutig erkannt werden kann. D.h. der Schlüssel sollte aus den Informationen gebildet werden, die Du auch zum Auffinden des Preises nimmst. Also: Beim füllen der map rufst Du zuerst eine Funktion CalcKey() auf, die den Schlüssel berechnet, unter dem etwas wiedergefunden werden kann. Die selbe Funktion CalcKey() ist dann auch die Erste, die GetPreis() aufruft, um den Schlüssel für das gesuchte Element zu berechnen.
Dann stellt sich natürlich die Frage, wie man so einen Schlüssel erstellt? Dazu gibt es viele Möglichkeiten und das wäre ein Thema für einen neuen Thread. In diesem Fall wird eine einfache Hashfunktion ausreichen.

Hans
--
Man muss nicht alles wissen, aber man sollte wissen, wo es steht. Zum Beispiel hier: Nachdenkseiten oder Infoportal Globalisierung.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
27.07.2013, 19:29 Uhr
YumiFerrari



Hallo Hans,

danke für die Erläuterung.

Also ich habe bis lang nur einen Programmcode, womit ich die Datei öffne und 2 Spalten auslese. In der einen stehen die Namen und in der anderen die Adresse. Diese werden dann in eine map gespeichert. Wie du schon gesagt hast, hat jeder Name eine bestimmte Adresse. Das blöde ist, dass sich einige Namen wiederholen. Die Adresse ist jedoch anders. Daher werden die Namen überschrieben und ich bekomme immer einen Output raus. Daher muss ich die Spalte mit den Levels mit betrachten. Daher weiß ich nicht, wie ich das mit in die Map hinzufügen kann.


Ehrlich gesagt, bin ich auch total verwirrt und weiß nicht wie ich das weiter machen soll. Und das schlimme ist, dass ich das bis Montag fertig haben muss


Ich würde gern mein programmcode hier zeigen, aber das ist viel zu lang, dass ich das hier nicht posten kann. Kann ich das irgendwie als ne txt Datei hinzufügen? Dann kann ich die Tabelle auch hinzufügen.....
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
27.07.2013, 19:38 Uhr
YumiFerrari




C++:
#include <iostream>
#include <fstream>
#include <string>
// #include <string.h> // Die C++ Stringfunktionen sollten eigentlich reichen. Die C-Stringfunktionen
                        // braucht man dann nicht mehr
#include <map>
#include <vector>
#include <utility>
#include <sstream>
#include <stdio.h>  // Das sollte man in C++ nicht verwenden.
// #include <time.h>   // Das ersetzen durch #include <ctime>
#include <ctime>

using namespace std;


typedef struct ODK_DATA_STRUCT
{
    unsigned char dataType;     // Data Type of memory
    unsigned short quantity;     // Quantity of data types
    unsigned short dbNumber;     // DB number if data type is a DB
    unsigned char memoryArea;     // Memory Area type
    unsigned short areaOffset;     // Offset into memory area
    unsigned char bitNumber;     // Bit number of data
    unsigned char* pBuff;         // Pointer to the data buffer
    unsigned short maxSize;     // Maximum size in bytes of buffer
    unsigned int status;         // Status of the read/write operation
} ODK_DATA_STRUCT;                 // Data structure for use with Read/Write functions

// Data Types
// Elementary Data Types

#define ODK_DATA_TYPE_BOOL 0x01     // Bit
#define ODK_DATA_TYPE_BYTE 0x02     // Byte
#define ODK_DATA_TYPE_CHAR 0x03     // Char
#define ODK_DATA_TYPE_WORD 0x04     // Word
#define ODK_DATA_TYPE_INT 0x05         // Integer
#define ODK_DATA_TYPE_DWORD 0x06     // Double Word
#define ODK_DATA_TYPE_DINT 0x07     // Double Integer
#define ODK_DATA_TYPE_REAL 0x08     // Real
#define ODK_DATA_TYPE_DATE 0x09     // Date
#define ODK_DATA_TYPE_TOD 0x0A         // TOD
#define ODK_DATA_TYPE_TIME 0x0B     // TIME
#define ODK_DATA_TYPE_S5TIME 0x0C     // S5TIME


// Complex Data Types
#define ODK_DATA_TYPE_DATE_AND_TIME 0x0E     // Date and Time
#define ODK_DATA_TYPE_STRING 0x13             // S7 String

// Parameter Data Types
#define ODK_DATA_TYPE_DATABLOCK 0x19     // All of data block
#define ODK_DATA_TYPE_COUNTER 0x1C         // Counter
#define ODK_DATA_TYPE_TIMER 0x1D         // Timer

// Memory areas
#define ODK_MEM_AREA_P 0x80     // (P) Peripheral
#define ODK_MEM_AREA_E 0x81     // (E) Process image input
#define ODK_MEM_AREA_A 0x82     // (A) Process image output
#define ODK_MEM_AREA_M 0x83     // (M) Flag
#define ODK_MEM_AREA_DB 0x84    // (DB1) Data Block 1
#define ODK_MEM_AREA_DS 0x01    // (DS) Data Set
#define ODK_MEM_AREA_SD 0x03     // (SD) AS200:SYS-AREA
#define ODK_MEM_AREA_S 0x04     // (S) AS200:stage bits
#define ODK_MEM_AREA_SF 0x05     // (SF) AS200:special flag
#define ODK_MEM_AREA_AI 0x06     // (AI) AS200:analog input
#define ODK_MEM_AREA_AQ 0x07     // (AQ) AS200:analog output
#define ODK_MEM_AREA_SZL 0x08     // (SZL) System State List


// Parameter Type Memory Areas
#define ODK_MEM_AREA_DATABLOCK 0x00     // (all of DATA BLOCK) Area for parameter type DB
#define ODK_MEM_AREA_COUNTER 0x1C         // (COUNTER) Area for paramter type COUNTER
#define ODK_MEM_AREA_TIMER 0x1D         // (TIMER) Area for parameter type TIMER


// Self defined

// #define FILEPATH "C\Documents and Settings\\SIMOTION\\Desktop\\Tabelle2.csv"
#define FILEPATH "C:\\Daten\\MinGW\\Tabelle2.csv"    // Datei im selben Verzeichnis wie das Programm
#define MinColumnSize 1
#define MaxColumnSize 4


class TableReader
{
    std::map<string, ODK_DATA_STRUCT> dataMap;

public:
    ODK_DATA_STRUCT dataStructForShortName(string shortName);
    void getAddress(string searchname);
    TableReader();
    ~TableReader();

private:
    map<string, ODK_DATA_STRUCT> loadMapFromCSV();
};



unsigned short shortFromString(string string)
{

    stringstream ss(string);
    unsigned short i;
    if( (ss >> i).fail() )
        {
//error
//cout << "Error transcoding string " << string << "to number" << endl;
            return i;
        }
    else
        {

            return i;
        }

}

void replaceAll(std::string& str, const std::string& from, const std::string& to)
{
    if(from.empty())
        return;
    size_t start_pos = 0;
    while((start_pos = str.find(from, start_pos)) != std::string::npos)
        {
            str.replace(start_pos, from.length(), to);
            start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
        }
}


void split(const string& s, char c, vector<string>& v)
{
// Used to split strings by given delimiter (for analyzing the rtName)
    string::size_type i = 0;
    string::size_type j = s.find(c);
    while (j != string::npos)
        {
            v.push_back(s.substr(i, j-i));
            i = ++j;
            j = s.find(c, j);
            if (j == string::npos)
                v.push_back(s.substr(i, s.length( )));
        }
}

TableReader::TableReader()
{
    dataMap = loadMapFromCSV();
}

TableReader::~TableReader()
{
// delete dataMap;
}


-----
Edit: Listing neu formatiert (AStyle -A7 filename) und cpp-Tags eingefügt

Dieser Post wurde am 28.07.2013 um 00:11 Uhr von Hans editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
27.07.2013, 19:41 Uhr
YumiFerrari




C++:
map<string, ODK_DATA_STRUCT> TableReader::loadMapFromCSV ()
{      
    ifstream MyFile;
    string String;
    int z=0; // Used for endless while loops
    string Zeile = " ";
    char delimiter[] = ";";
    char* pointer_mychar;
    map<string, ODK_DATA_STRUCT> names;
        
    
    MyFile.open (FILEPATH);
    if (!MyFile)
    {
        printf ("Fehler beim Oeffnen der Datei!\n");
        throw 10;
    }
    else
        // printf ("Die Datei wurde geoeffnet!\n");
        
        MyFile.seekg (0, ios::beg);
    

    while(z<1)
    {
        
        string shortName; // The short name given in the CSV file
        string rtName; // The rtName given in the CSV file
        string datatypeStringFromTable; // The data Type given in the CSV
        int dataTypeNumRep; // An integer representation of the datatypeStringFromTable
        ODK_DATA_STRUCT dataStruct; // The data struct to be filled
        vector<string> v; // Initing the vector where we are going to put the two parts of the rtName
        
        getline(MyFile, String);
        if (String != Zeile) // If the line is not empty
        {
            Zeile = String;
            pointer_mychar = &String[0];
            
            pointer_mychar = strtok(pointer_mychar, delimiter);
            
            int i=0;
            int pairfind = 0;
            
            
            while(pointer_mychar != NULL)
            {
                if (i>MinColumnSize && i<  MaxColumnSize) // Reading column 2-4 only.  
                {
                    
                    if (pairfind == 0) {  
                        shortName = pointer_mychar; // First collum is the short Name
                        pairfind = 1;
                    } else if(pairfind == 1) {
                        rtName = pointer_mychar; // Second collum is the rtName which will be analyzed here
                        size_t position =rtName.find("]");
                        rtName.erase(0, position+1);

                        split(rtName, ',', v); // Splitting by a ,
                        
                        pairfind = 2;
                    } else {
                        datatypeStringFromTable = pointer_mychar;
                        
                                              dataTypeNumRep = i;
                        pairfind = 0; // Resetting pairfind for a new round
                    }
                }
                pointer_mychar = strtok(NULL, delimiter);
                
                i++;
            }
        } else {
            break;
        }
        
        string firstPartOfrtName;
        string secondPartOfrtName;
        
        if (v.size() == 2) {
            firstPartOfrtName = v[0];
            secondPartOfrtName = v[1];
        } else {
        firstPartOfrtName = "";
            secondPartOfrtName = "";
        }
        
        if (firstPartOfrtName.find("DB") != string::npos) {
            dataStruct.memoryArea = ODK_MEM_AREA_DB;
            replaceAll(firstPartOfrtName, "DB", "");
            dataStruct.dbNumber = shortFromString(firstPartOfrtName);
            
        } else if (firstPartOfrtName.find("PAB")!= string::npos) {
            dataStruct.memoryArea = ODK_MEM_AREA_A;
            replaceAll(firstPartOfrtName, "PAB", "");
            dataStruct.areaOffset = shortFromString(firstPartOfrtName);  
            
        } else if (firstPartOfrtName.find("PEB")!= string::npos) {      
            dataStruct.memoryArea = ODK_MEM_AREA_E;
            replaceAll(firstPartOfrtName, "PEB", "");
            dataStruct.areaOffset = shortFromString(firstPartOfrtName);
            
        } else if (firstPartOfrtName.find("M")!= string::npos) {    
          // klappt nocht nicht, wenn Merker eine offset und bit number angibt
           replaceAll(secondPartOfrtName, "M", "");
            dataStruct.dataType = ODK_MEM_AREA_M;
            vector<string> p;
            if (firstPartOfrtName.find(".") != string::npos ) {
                split(firstPartOfrtName, '.', p);
                if (p.size() >= 1) {
                    dataStruct.areaOffset = shortFromString(firstPartOfrtName);
                    
                    dataStruct.bitNumber = shortFromString(p[1]);
                }
            }
            
            else {
                dataStruct.areaOffset = shortFromString(firstPartOfrtName);
                
            }
        } else if (firstPartOfrtName.find("MD")!= string::npos) {
             dataStruct.memoryArea = ODK_MEM_AREA_M;
            
            replaceAll(firstPartOfrtName, "MD", "");
            dataStruct.areaOffset = shortFromString(firstPartOfrtName);
        
        } else if (firstPartOfrtName.find("MW")!= string::npos) {
            dataStruct.memoryArea = ODK_MEM_AREA_M;
            
            replaceAll(firstPartOfrtName, "MW", "");
            dataStruct.areaOffset = shortFromString(firstPartOfrtName);
        }

        

/* Second part of RTName after the comma */

        if (secondPartOfrtName.find("STRING") != string::npos) {
            replaceAll(secondPartOfrtName, "STRING", "");
            dataStruct.dataType = ODK_DATA_TYPE_STRING;
            vector<string> p;
            if (secondPartOfrtName.find(".") != string::npos ) {
                split(secondPartOfrtName, '.', p);
                if (p.size() >= 1) {
                    dataStruct.areaOffset = shortFromString(secondPartOfrtName);
                    
                    dataStruct.maxSize = shortFromString(p[1]);
                }
            }
            
            else {
                dataStruct.areaOffset = shortFromString(firstPartOfrtName);    
            }

        } else  if (secondPartOfrtName.find("DWORD") != string::npos) {
            replaceAll(secondPartOfrtName, "DWORD", "");
            dataStruct.dataType = ODK_DATA_TYPE_DWORD;
            vector<string> p;
            
            if (secondPartOfrtName.find(".") != string::npos ) {
                split(secondPartOfrtName, '.', p);
                if (p.size() >= 1) {
                    dataStruct.areaOffset = shortFromString(p[0]);
                    dataStruct.bitNumber = shortFromString(p[1]);
                }
            }
           else {
                dataStruct.areaOffset = shortFromString(secondPartOfrtName);
                
            }
          
           int size;
           size = 4;

             dataStruct.maxSize = size;

          
        }


-----
Edit: cpp-Tags eingefügt

Dieser Post wurde am 28.07.2013 um 00:15 Uhr von Hans editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
27.07.2013, 19:43 Uhr
YumiFerrari




C++:
else  if (secondPartOfrtName.find("X") != string::npos) {
            replaceAll(secondPartOfrtName, "X", "");
            dataStruct.dataType = ODK_DATA_TYPE_BYTE;
            vector<string> p;
            if (secondPartOfrtName.find(".") != string::npos ) {
                split(secondPartOfrtName, '.', p);
                if (p.size() >= 1) {
                    dataStruct.areaOffset = shortFromString(p[0]);
                    dataStruct.bitNumber = shortFromString(p[1]);
                    
                }
            }
            
            else {
                dataStruct.areaOffset = shortFromString(secondPartOfrtName);
            }
        } else  if (secondPartOfrtName.find("B") != string::npos && secondPartOfrtName.find("SFB") == string::npos) {
            replaceAll(secondPartOfrtName, "B", "");
            dataStruct.dataType = ODK_DATA_TYPE_BOOL;
            vector<string> p;
            if (secondPartOfrtName.find(".") != string::npos ) {
                split(secondPartOfrtName, '.', p);
                if (p.size() >= 1) {
                    dataStruct.areaOffset = shortFromString(p[0]);
                    dataStruct.bitNumber = shortFromString(p[1]);
                }
            }
            
            else {
                dataStruct.areaOffset = shortFromString(secondPartOfrtName);
                
            }
        } else  if (secondPartOfrtName.find("CHAR") != string::npos) {
            replaceAll(secondPartOfrtName, "CHAR", "");
            dataStruct.dataType = ODK_DATA_TYPE_CHAR;
            vector<string> p;
            if (secondPartOfrtName.find(".") != string::npos ) {
                split(secondPartOfrtName, '.', p);
                if (p.size() >= 1) {
                    dataStruct.areaOffset = shortFromString(p[0]);
                    dataStruct.bitNumber = shortFromString(p[1]);
                    
                }
            }
            
            else {
               dataStruct.areaOffset = shortFromString(secondPartOfrtName);                
            }
        } else  if (secondPartOfrtName.find("REAL") != string::npos) {
            replaceAll(secondPartOfrtName, "REAL", "");
            dataStruct.dataType = ODK_DATA_TYPE_REAL;
            vector<string> p;
            if (secondPartOfrtName.find(".") != string::npos ) {
                split(secondPartOfrtName, '.', p);
                if (p.size() >= 1) {
                    dataStruct.areaOffset = shortFromString(p[0]);
                    dataStruct.bitNumber = shortFromString(p[1]);
                    
                }
            }
            
            else {
               dataStruct.areaOffset = shortFromString(secondPartOfrtName);                  
            }
        } else  if (secondPartOfrtName.find("INT") != string::npos) {
            replaceAll(secondPartOfrtName, "INT", "");
            if (secondPartOfrtName.find("D")!= string::npos) {
                replaceAll(secondPartOfrtName, "D", "");
                dataStruct.dataType = ODK_DATA_TYPE_DINT;
            } else {
            dataStruct.dataType = ODK_DATA_TYPE_INT;
            }
            vector<string> p;
            if (secondPartOfrtName.find(".") != string::npos ) {
                split(secondPartOfrtName, '.', p);
                if (p.size() >= 1) {
                    dataStruct.areaOffset = shortFromString(p[0]);
                    dataStruct.bitNumber = shortFromString(p[1]);
                }
            }
            
            else {
                 dataStruct.areaOffset = shortFromString(secondPartOfrtName);                
            }
        } else  if (secondPartOfrtName.find("TOD") != string::npos) {
            replaceAll(secondPartOfrtName, "TOD", "");
            dataStruct.dataType = ODK_DATA_TYPE_TOD;
            vector<string> p;
            if (secondPartOfrtName.find(".") != string::npos ) {
                split(secondPartOfrtName, '.', p);
                if (p.size() >= 1) {
                    dataStruct.areaOffset = shortFromString(p[0]);
                    dataStruct.bitNumber = shortFromString(p[1]);
                }
            }
            
            else {
               dataStruct.areaOffset = shortFromString(secondPartOfrtName);    
                
            }
        } else  if (secondPartOfrtName.find("WORD") != string::npos) {
            replaceAll(secondPartOfrtName, "WORD", "");
            dataStruct.dataType = ODK_DATA_TYPE_WORD;
            vector<string> p;
            if (secondPartOfrtName.find(".") != string::npos ) {
                split(secondPartOfrtName, '.', p);
                if (p.size() >= 1) {
                    dataStruct.areaOffset = shortFromString(p[0]);
                    dataStruct.bitNumber = shortFromString(p[1]);          
                }
            }
            
             else {
                dataStruct.areaOffset = shortFromString(secondPartOfrtName);
            }
        }
  
    
        names.insert(std::pair<string, ODK_DATA_STRUCT>(shortName,dataStruct));
        // Inserting finished pair into map
  
    }
  
    
    cout << "Read Process Complete!" << endl; // Debbung logs
    cout << "Map size: " << names.size() << endl;
    MyFile.close(); // Datei wird geschlossen
    return names;
}


ODK_DATA_STRUCT TableReader::dataStructForShortName(string shortName){
    
    ODK_DATA_STRUCT dataStruct = dataMap[shortName];
    return dataStruct;    
}


-----
Edit: cpp-Tags eingefügt

Dieser Post wurde am 28.07.2013 um 00:16 Uhr von Hans editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
27.07.2013, 19:44 Uhr
YumiFerrari




C++:
int main ()
{  TableReader tableReader;
    while (true) {
    cout << "Enter string to search for" << endl;
        string searchString;
        cin >> searchString;

  ODK_DATA_STRUCT dStruct = tableReader.dataStructForShortName(searchString);
        // How to call the previous function
        
        string dataTypeName;
        if (dStruct.dataType == ODK_DATA_TYPE_BOOL)
        {
            dataTypeName = "BOOL";
        }
        else if (dStruct.dataType == ODK_DATA_TYPE_BYTE)
        {
            dataTypeName = "BYTE";
        }
        else if (dStruct.dataType == ODK_DATA_TYPE_CHAR)
        {
            dataTypeName = "CHAR";
        }
        else if (dStruct.dataType == ODK_DATA_TYPE_WORD)
        {
            dataTypeName = "WORD";
        }
        else if (dStruct.dataType == ODK_DATA_TYPE_INT)
        {
            dataTypeName = "INT";
        }
        else if (dStruct.dataType == ODK_DATA_TYPE_DWORD)
        {
            dataTypeName = "DWORD";
        }
        else if (dStruct.dataType == ODK_DATA_TYPE_DINT)
        {
            dataTypeName = "DINT";
        }
        else if (dStruct.dataType == ODK_DATA_TYPE_REAL)
        {
            dataTypeName = "REAL";
        }
        else if (dStruct.dataType == ODK_DATA_TYPE_DATE)
        {
            dataTypeName = "DATE";
        }
        else if (dStruct.dataType == ODK_DATA_TYPE_TOD)
        {
            dataTypeName = "TOD";
        }
        else if (dStruct.dataType == ODK_DATA_TYPE_TIME)
        {
            dataTypeName = "TIME";
        }
        else if (dStruct.dataType == ODK_DATA_TYPE_S5TIME)
        {
            dataTypeName = "S5TIME";
        }
        
        
        string memAreaName;
        if (dStruct.memoryArea == ODK_MEM_AREA_A)
        {
            memAreaName = "Process image output";
        }
        else if (dStruct.memoryArea == ODK_MEM_AREA_AI)
        {
            memAreaName = "analog input";
        }
        else if (dStruct.memoryArea == ODK_MEM_AREA_E)
        {
            memAreaName = "Process image input";
        }
        else if (dStruct.memoryArea == ODK_MEM_AREA_M)
        {
            memAreaName = "Flag";
        }
        else if (dStruct.memoryArea == ODK_MEM_AREA_DB)
        {
            memAreaName = "DB";
        }
        else if (dStruct.memoryArea == ODK_MEM_AREA_DS)
        {
            memAreaName = "Data Set";
        }
        else if (dStruct.memoryArea == ODK_MEM_AREA_SD)
        {
            memAreaName = "SYS-Area";
        }
        else if (dStruct.memoryArea == ODK_MEM_AREA_SF)
        {
            memAreaName = "special flag";
        }
        else if (dStruct.memoryArea == ODK_MEM_AREA_AQ)
        {
            memAreaName = "Analog output";
        }
        else if (dStruct.memoryArea == ODK_MEM_AREA_SZL)
        {
            memAreaName = "System State List";
        }
        else if (dStruct.memoryArea == ODK_MEM_AREA_COUNTER)
        {
            memAreaName = "COUNTER";
        }
        else if (dStruct.memoryArea == ODK_MEM_AREA_TIMER)
        {
            memAreaName = "TIMER";
        }
        else if (dStruct.memoryArea == ODK_MEM_AREA_P)
        {
            memAreaName = "P";
        }
        
        cout << "Data Type:   " << dataTypeName << endl;
        cout << "Quantity:    " << dStruct.quantity << endl;
        cout << "db Number:   " << dStruct.dbNumber << endl;
        cout << "Memory Area: " << memAreaName << endl;
        cout << "Area Offset: " << dStruct.areaOffset << endl;
        printf ("bitNumber:   %d\n", dStruct.bitNumber );
        //cout << "pBuff:       " << dStruct.pBuff << endl;
        cout << "max Size:    " << dStruct.maxSize << endl;
        // cout << "status:      " << dStruct.status << endl;
        
        cout << "------------------------------------" << endl;
        }      
  
    return 0;
}


-----
Edit: cpp-Tags eingefügt

Dieser Post wurde am 28.07.2013 um 00:17 Uhr von Hans editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
27.07.2013, 19:45 Uhr
YumiFerrari



das tut mir leid, dass ich das hier grad zu texte mit dem code..... ja wenn mir einer sagen könnte, wie ich die tabelle hochlade, wäre das super. ich weiß echt nicht weiter und hoffe auf hilfe. Hans könntest du mir denn weiter helfen? bin für jeden Hinweis dankbar.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ] [ 3 ]     [ C / C++ (WinAPI, Konsole) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: