---
name: "table"
section: "3bobcat"
platform: "linux"
package: "libbobcat-dev"
version: "6.07.01-2"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/table/3bobcat"
---

# table(3bobcat)

Generates row- or column-wise filled tables

## NAME

FBB::Table - Generates row- or column-wise filled tables

## SYNOPSIS

**#include \<bobcat/table\>**\
 Linking option: *-lbobcat*

## DESCRIPTION

**FBB::Table** objects can be used to create tables. Tables are filled either column- or row-wise. Many of the table’s characteristics may be fine-tuned using a separate **FBB::TableSupport** object (cf. [**tablesupport**(3bobcat)](/tablesupport/3bobcat.md)). When no **FBB::TableSupport** object is used, a plain table, filled row-wise or column-wise, is constructed which can be inserted into a **std::ostream**.

Tables defined by *Table* consist of rows and a fixed number of columns. The number of columns is specified at construction time, the number of rows also depends on the number of inserted elements. Columns and rows are addressed using indices (starting at 0). Before the leftmost column, between the columns and beyond the last column *separators* are defined. By default these separators are empty, but each separator may be given a (fixed) width or content. The separator before column *col* is addressed as separator *col*, the rightmost separator is addressed as separator *nColummns*.

Rows can also be separated from each other using separators. These separating rows are empty by default. The row-separator before row *row* is addressed as row-separator *row*. The row-separator following the final row is addressed as row-separator *nRows*, where *nRows* is the value returned by the *nRows* member function.

Non-default (i.e., non-empty) separators are defined using *FBB::TableSupport* objects (cf. [**tablesupport**(3bobcat)](/tablesupport/3bobcat.md)).

*Table* objects look a lot like *ostream* objects, using a simple way to define new elements: each new insertion defines another table element, and it is difficult to end a row before it has received its *nColumn* number of elements. *Table*’s sister-class, *TableBuf*, is a *std::streambuf* type of class, offering additional control through the use of a wrapping *ostream* class object.

## NAMESPACE

**FBB**\
 All constructors, members, operators and manipulators, mentioned in this man-page, are defined in the namespace **FBB**.

## INHERITS FROM

**std::ostringstream** - *Table* inherits from **std::ostringstream**, allowing insertions into a **Table** object. Each separate insertion adds another element to the **Table** object.

**FBB::TableBase** - This class implements common elements of the table implementation. The *TableBase* class is not intended to be used by itself, and no separate man-page is provided. Facilities provided by *Table* which were inherited from *TableBase* are described in this man-page.

## ENUMERATIONS

The following enumerations are defined by the class **FBB::Table**: **enum FillDirection**\
 This enumeration defines two values:

- o

  **ROWWISE**:\
   When this value is specified at construction time, elements are added row-wise to the table. I.e., the second element inserted into the *Table* will be found in the second column of the first row;

- o

  **COLUMNWISE**:\
   When this value is specified at construction time, elements are added column-wise to the table. I.e., the second element is found in the second row of the first column.

**enum WidthType**\
 This enumeration defines two values:

- o

  **COLUMNWIDTH**:\
   Specify this value when the columns may have variable widths. In this case each column will be as wide as its widest element. This is the default *WidthType* used by *Table* objects.

- o

  **EQUALWIDTH**:\
   Specify this value when all of the table’s columns must have equal widths (i.e., equal to the width of the widest table element),

## CONSTRUCTORS

- o

  **Table(size\_t nColumns, Table::FillDirection direction,** **Table::WidthType widthType = Table::COLUMNWIDTH)**:\
   The table’s number of columns, the fill directions and the column width-type must be provided.  The number of rows is implied by the combination of this parameter and the number of elements that is actually inserted into the *Table* object.  The *direction* parameter specifies the way new elements are added to the *Table* object: row-wise or column-wise. Finally, the *widthType* parameter is used to specify the way the width of the table’s columns is determined. Each column either defines its own width or all columns have equal widths.

- o

  **Table(TableSupport &tableSupport, size\_t nColumns,** **Table::FillDirection direction,** **Table::WidthType widthType = Table::COLUMNWIDTH)**:\
   This constructor operates identically to the previous constructor, but expects an additional reference to a *TableSupport* object. A *TableSupport* object offers additional formatting features used by the table defining elements like horizontal lines between rows, additional separators, etc, etc. The *TableSupport* object is passed as a non-const reference as the *Table* object must be able to manipulate its data. See **tablesuppport**(3bobcat) for more information about *TableSupport*.

Copy and move constructors (and assignment operators) are not available.

## OVERLOADED OPERATORS

- o

  **std::ostream &operator\<\<(std::ostream &str, Table &table)**:\
   This operator inserts a *Table* into a *std::ostream* object.  This operator requires a non-const table as it may have to complete the table by adding empty elements (i.e., empty strings) to obtain a completely filled rectangular table;

- o

  **Table &operator\<\<(Table &obj, Align const &align)**:\
   This operator changes the default alignment of either a column or an element. It is a wrapper around the member *setAlign* (see below for its description). By default, all elements are right-aligned (see also [**align**(3bobcat)](/align/3bobcat.md));

- o

  **Table &operator\<\<(Table &obj, Type const &item)**:\
   This operator is defined as a function template: *Type* is a template type parameter instantiated to a type for which *std::ostringstream* insertions are possible.  It inserts the value/object *item* into the *Table*’s *std::ostringstream* base class object as the table’s next element.

## MEMBER FUNCTIONS

- o

  **Table &append(std::string const &text** **char const \*sep = " \\t", bool addEmpty = false)**:\
   Fields in *text* separated by one of the characters in *sep* are added as elements to the *Table* object. Empty fields are ignored unless the parameter *addEmpty* is *true*;

- o

  **void clear()**:\
   The content of the table is erased;

- o

  **void clearStr()**:\
   The content of its *std::ostringstream* base class buffer is erased;

- o

  **Table &def()**:\
   After inserting elements into a *Table* object its number of elements may or may not be an integral multiple of the number of columns specified at construction time. To \`complete’ a *Table* object to a rectangular object, for which all column widths and alignments have been determined *def* can be called. It is automatically called by *operator\<\<(ostream, Table)*. In other situations it may be called explicitly to force the insertion of another row in a table using *ROWWISE* insertions. With *COLUMNWISE* insertions its working is complex, since new elements added to a *COLUMNWISE* filled table will reshuffle its elements over the table’s columns;

- o

  **void fill(InputIterator begin, InputIterator end)**:\
   This member is defined as a member template; *InputIterator* is a template type parameter representing any input iterator. It can also be, e.g., a pointer to an insertable type. The iterators must point to data elements which can be inserted into an *std::ostream*. The range of values implied by the member’s iterator pair are inserted into the table as new elements;

- o

  **void push\_back(std::string const &element)**:\
   New elements can be added to the table using *push\_back*. It could e.g., be called from a *back\_inserter* adaptor;

- o

  **size\_t nRows()**:\
   The table’s current number of rows is returned. It is initialized to 0, and after that updated when *def* has been called;

- o

  **Table &setAlign(Align const &align)**:\
   The alignment type of either a column or an element of the *Table* object is defined using *setAlign*. The standard alignments *std::left, std::right* and *std::internal* may be specified, but in addition the alignment *FBB::center* may be used if elements should be centered into their column. A construction like

  ```
  tab << Align(2, FBB::center)
  ```

  requests centering of all elements in the table’s column having index value 2 (i.e., the table’s 3rd column), whereas a construction like

  ```
  tab << Align(2, 3, FBB::center)
  ```

  requests centering of element \[2\]\[3\]. It is the responsibility of the programmer to ensure that such elements exist. By default, all elements are right-aligned. )

## MANPULATORS

- o

  **Table &def(Table &table)**:\
   This manipulator can be inserted into a table to call the table’s *def* member.

## EXAMPLE

```
#include <iostream>
#include <bobcat/table>
#include <bobcat/tablelines>
using namespace std;
using namespace FBB;
int main(int argc, char **argv)
{
    TableLines tablelines;
                                // width/separators of cols 0, 1 and 2
    tablelines << 0 << " | " << " | ";
                                // hline over cols 1 and 2 of row 1
    tablelines << TableLines::HLine(1, 1, 3);
    Table tab(tablelines, 3, Table::ROWWISE, Table::EQUALWIDTH);
    // or: Table tab(tablelines, 3, Table::ROWWISE);
    tab << Align(0, std::left);     // set column non-default alignment
    tab.fill(argv + 1, argv + argc);// fill range of values
    cout << tab << ’\n’;            // complete the table and insert
    tab << "hello" << "" << "wo";   // add additional elements.
    if (tab.nRows() > 2)
        tab << Align(2, 2, center); // set the layout of a specific element
    cout << tab << ’\n’;
}
```

## FILES

*bobcat/table* - defines the class interface;\

## SEE ALSO

[**bobcat**(7)](/bobcat/7.md), [**align**(3bobcat)](/align/3bobcat.md), [**csvtable**(3bobcat)](/csvtable/3bobcat.md), **manipulator**(3bobcat), [**tablebuf**(3bobcat)](/tablebuf/3bobcat.md), [**tablelines**(3bobcat)](/tablelines/3bobcat.md), [**tablesupport**(3bobcat)](/tablesupport/3bobcat.md)

## BUGS

Note that *def()* will reshuffle elements over the table’s columns when new elements are added to the table subsequent to calling *def()*

## BOBCAT PROJECT FILES

- o

  *https://fbb-git.gitlab.io/bobcat/*: gitlab project page;

Debian Bobcat project files:

- o

  *libbobcat6*: debian package containing the shared library, changelog and copyright note;

- o

  *libbobcat-dev*: debian package containing the static library, headers, manual pages, and developer info;

## BOBCAT

Bobcat is an acronym of \`Brokken’s Own Base Classes And Templates’.

## COPYRIGHT

This is free software, distributed under the terms of the GNU General Public License (GPL).

## AUTHOR

Frank B. Brokken (**f.b.brokken@rug.nl**).