C ++ open source-bibliotheek voor opgemaakte uitvoer van een tabel

Is er een open source C ++ -bibliotheek voor het formatteren van tabellen?

Iets dat me in staat stelt te schrijven

Table t;// Table is a class provided by the library
t.column(2);
t.name(0,"x");
t.name(1,"x^2");
t.type("x",Table::Integer);
t.type("x^2",Table::Integer);
t.width("x",1);
t.width("x^2",2);
for( size_t i = 0; i < 10; i++ ) {
 t.set("x",i);
 t.set("x^2",i*i);
}
std::cout << t;

en krijg deze tekstuele uitvoer

0  0
1  1
2  4
3  9
4 16
5 25
6 36
7 49
8 64
9 81

Het moet in staat zijn om ook drijvende-kommagetallen te beheren, niet alleen gehele getallen. Dank je.

2

2 antwoord

I am not aware of any libraries.
But you can overload the << operator for your class Table and you can achieve the same.

EDIT:
To clarify on your comment of Table being an Library class, It does not affect overloading the << because it is overloaded as an non-member free function.

Codevoorbeeld:

std::ostream& operator<<(std::ostream& os, const Table& obj) 
{ 
 //write obj to stream in whichever way you like
  return os;
} 
2
toegevoegd
Tabel wordt verondersteld een klasse te zijn die wordt geleverd door de bibliotheek. Ik zal de vraag verduidelijken.
toegevoegd de auteur Alessandro Jacopson, de bron
misschien heb ik mijn probleem niet genoeg uitgelegd. Ik heb alleen de getallen i en i ^ 2 en de bibliotheek waar ik naar op zoek ben, zou me een klas zoals Tafel moeten geven.
toegevoegd de auteur Alessandro Jacopson, de bron
@uvts_cvs: << wordt meestal overbelast als een niet-leden-functie, dus het zou geen probleem moeten zijn.
toegevoegd de auteur Alok Save, de bron

De voorgebouwde bibliotheken die ik ken voor dit soort dingen zijn meestal GUI-gericht, dus de gegevens worden weergegeven in spreadsheetachtige cellen in plaats van alleen als tekst.

Kijkend naar je idee van hoe je de bibliotheek te gebruiken, lijkt het mij passend als C + + nogal slecht. Houd er rekening mee dat C ++ statisch typen gebruikt, waarbij uw t.type ("x", Table :: Integer) meestal dynamisch typen impliceert (dwz het type van die kolom opgeven tijdens runtime in plaats van compileer tijd).

Persoonlijk zou ik waarschijnlijk denken in termen van een opmaakobject dat opmaakinformatie voor één -object heeft opgeslagen. U zou dan een "kolom" met een opmaakobject en een vector van bijbehorende gegevens hebben. Ten slotte zou u een "tabel" hebben met een willekeurig aantal kolommen. Het meeste hiervan (met name de typen) zou worden gespecificeerd als sjabloonargumenten, dus misschien heeft u iets als:

class format { 
    int w, p;
public:
    format(int width = 0, int precision = 0) : w(width), precision(p) {}

    friend std::ostream &operator<<(std::ostream &os, format const &f) { 
        return os << std::setw(f.w) << std::setprecision(f.p);
    }
};

template  >
class Column {
    format f;
    std::string label;
    container data;
public:
    Column(std::string const &l, format const &fmt) : f(fmt), label(l) {}
    void push_back(T const &d) { data.push_back(d); }
};

format fmt1(1);
format fmt2(2);

Column c1("x", fmt1);
Column c2("x^2", fmt2);

table<2> my_table(c1, c2);

I'd probably then design the table to act roughly like a vector >, so to add the values, you'd do something like:

for (int i=0; i<10; i++)
    my_table.push_back(make_tuple(i, i*i));

The method you've used (based on the name of the column instead of the position) could probably be done, but the obvious way (a map) would only work if all the columns had the same type. To support multiple column types, you could do something like map, but I'd stay away from that if at all reasonable.

1
toegevoegd
+1 Bedankt voor je antwoord. Ik denk dat ik iets zal proberen te coderen op basis van je suggesties.
toegevoegd de auteur Alessandro Jacopson, de bron