Main Page   Namespace List   Class Hierarchy   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

A Tutorial Example


It is easiest to understand how the GNU cgicc library might be used by first looking at an example. Suppose you want an HTML form on your web site asking a user to enter their name, age, and sex, perhaps as part of a user-registration procedure, and you wish to write a CGI script using cgicc to process the form in some meaningful way.

You would begin by creating an HTML form containing the HTML fragment

<form method="post" action="http://change_this_path/cgi-bin/foo.cgi">
Your name : <input type="text" name="name" /><br />
Your age : <input type="text" name="age" /><br />
Your sex : <input type="radio" name="sex" value="male"checked="checked" />Male
<input type="radio" name="sex" value="female" />Female <br />

Then, on to the CGI application. Applications written using cgicc, like all other applications, begin with a main function:

int main(int argc, char **argv)
   // CGI processing goes here


The three main classes of cgicc you will use to process the submitted data are cgicc::Cgicc, cgicc::CgiEnvironment, and cgicc::FormEntry. These classes will be explained in detail later; for now, it is sufficient to know that:

All of cgicc's functionality is accessed through class cgicc::Cgicc. Thus, the first step in CGI processing is to instantiate an object of type cgicc::Cgicc:

cgicc::Cgicc cgi;


using namespace cgicc;
Cgicc cgi;

Upon instantiation, the class cgicc::Cgicc parses all data passed to the CGI script by the HTTP server.

Since errors are handled using exceptions, you may wish to wrap your CGI code in a try block to better handle unexpected conditions:

try {
   cgicc::Cgicc cgi;

catch(exception& e) {
   // Caught a standard library exception

Extracting Form Information

Each element of data entered by the user is parsed into a cgicc::FormEntry. A cgicc::FormEntry contains methods for accessing data as strings, integers, and doubles. In the form mentioned above, a user would enter their name, age, and sex. Regardless of the type of value, the data is accessed using cgicc::FormEntry (this is not entirely true. For uploaded files, the data is accessed via the class cgicc::FormFile). You obtain cgicc::FormEntry objects via cgicc::Cgicc's getElement methods, all of which return typedefs of C++ standard template library (STL) iterators:

cgicc::form_iterator name = cgi.getElement("name");

If the item is not found, the iterator will refer to an invalid element, and should not be dereferenced using operator* or operator->. cgicc::Cgicc provides methods for determining whether an iterator refers to a valid element:

if(name != cgi.getElements().end()) {
   // iterator refers to a valid element

Output of Form Data

Once you have a valid element, you will more than likely want to do something with the data. The simplest thing to do is just echo it back to the user. You can extract a basic_string from a cgicc::FormEntry by calling the getValue method. Since ostream has an overload for writing basic_string objects, it is trivial to output objects of this type:

cout << "Your name is " << name->getValue() << endl;

Since both iterator and cgicc::FormEntry overload operator*, the code given above may also be written as:

cout << "Your name is " << **name << endl;

The first * returns an object of type cgicc::FormEntry, and the second * returns an object of type basic_string.

The HTTP Response

A CGI response will generally consist of an HTML document. The HTTP protocol requires that a certain set of headers precede all documents, to inform the client of the size and type of data being received, among other things. In a normal CGI response, the HTTP server will take care of sending many of these headers for you. However, it is necessary for the CGI script to supply the type of content it is returning to the HTTP server and the client. This is done by emitting a Content-Type header. If you're interested, the full HTTP 1.1 specification may be found in RFC 2068 at

cgicc provides several classes for outputting HTTP headers, all of which begin with HTTP. A standard HTML 4.0 document need only output a single header:

cout << cgicc::HTTPHTMLHeader() << endl;

This will generate the output

Content-Type: text/html\n\n

Simple HTML Output

cgicc provides one class for every HTML tag defined in the HTML 4.0 standard in the header file "cgicc/HTMLClasses.h". These classes have the same name as the HTML tags. For example, in HTML, to indicate the start of a document you write <html> ; this can be accomplished using cgicc by writing

cout << html() << endl;

The class html keeps state internally, so the code above will produce as output <html>; conversely, the code

cout << html() << "html text!" << html() << endl;

will produce as output <html>html text!</html>.

All of cgicc's HTML output classes are subclasses of the abstract class cgicc::HTMLElement. You can embed the text for the element directly in the constructor:

cout << html("html text!") << endl;

Furthermore, it is possible to embed one cgicc::HTMLElement in another:

cout << head(title("Title")) << endl;

This produces as output


And, if you wish be more specific about the type of HTML 4.0 you are going to return (strict, transitional, or frameset), you can use the class cgicc::HTMLDoctype before the cgicc::html tag:

cout << HTMLDoctype(HTMLDoctype::eStrict) << endl;

which produces


More Complex HTML Output

In real HTML, most tags possess a set of attributes. For example, the HTML <img> tag requires certain attributes specifying the source image file, the image width, height, and so on. There are a bewildering number of possible attributes in HTML 4.0. For a definitive list, see the HTML 4.0 specification at A typical <img> tag might look like:

<img src="file.jpg" width="100" height="100" alt="description" />

This tag has four attributes: src, width, height, and alt, with the values file.jpg, 100, 100, and description, respectively. Attributes in HTML tags are represented by the class cgicc::HTMLAttribute, which essentially is a name/value pair. To build an cgicc::HTMLElement containing cgicc::HTMLAttribute objects, use the set method on cgicc::HTMLElement. To generate the <img> tag given above:

cout << img().set("src", "file.jpg")
             .set("width", "100").set("height", "100")
             .set("alt", "description") << endl;

In a similar way, multiple cgicc::HTMLElement objects may be embedded at the same level inside another cgicc::HTMLElement. To build an cgicc::HTMLElement containing multiple embedded cgicc::HTMLElement objects, use the add method on cgicc::HTMLElement:

cout << tr().add(td("0")).add(td("1")).add(td("2")) << endl;

This produces as output


Notes on Output

All of cgicc's output is written to a C++ standard output stream, usually cout. It is not necessary to use cgicc's HTML output classes; they are provided as a convenience. If you prefer, you may output the HTML code directly to cout.

The Complete Example

The code below is a complete CGI program that synthesizes all the sample code given above.

#include <iostream>
#include <vector>
#include <string>

#include "cgicc/Cgicc.h"
#include "cgicc/HTTPHTMLHeader.h"
#include "cgicc/HTMLClasses.h"

using namespace std;
using namespace cgicc;

main(int argc, 
     char **argv)
   try {
      Cgicc cgi;

      // Send HTTP header
      cout << HTTPHTMLHeader() << endl;

      // Set up the HTML document
      cout << html() << head(title("Cgicc example")) << endl;
      cout << body() << endl;

      // Print out the submitted element
      form_iterator name = cgi.getElement("name");
      if(name != cgi.getElements().end()) {
         cout << "Your name: " << **name << endl;

      // Close the HTML document
      cout << body() << html();
   catch(exception& e) {
      // handle any errors - omitted for brevity

[ Previous: Library Overview | Current: A Tutorial Example | Next: GNU cgicc Demos ]

GNU cgicc - A C++ class library for writing CGI applications
Copyright © 1996 - 2002 Stephen F. Booth
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front Cover Texts, and with no Back-Cover Texts.
Documentation generated Sun Mar 17 16:40:57 2002 for cgicc by doxygen