The URI class

In addition to protocol implementations, the cpp-netlib provides a powerful URI class. The class implements a parser based on RFC 3986 and RFC 2732.

Generic URI syntax overview

A generic URI will take the form:


A URI is known as absolute if it specifies the scheme. Otherwise, it is known as a relative URI. Currently, uri supports only absolute URIs.

URIs can be further classified according to whether they’re hierarchical or opaque (non-hierarchical).

Some examples of non-hierarchical URIs include:

The data following the first ":" is said to be opaque to the URI parser and requires no further parsing. By way of example, the following shows how a non-hierarchical URI is processed by the parser by defining everything after the ":" to be a part of the path:


A hierarchical URI is identified by a double slash ("//") after the scheme and a scheme-specific component, which RFC 3986 defines to be:


The authority component can be further broken down to:


Examples of hierarchical URIs include:

The following example, describing a complex URI using FTP, shows how a URI is broken down by the parser:


Note that the authority is further subdivided into different elements. Another example, using HTTP is given below:


The difference here between the path in a hierarchical URI and that in the example above for the non-hierarchical URI.

The uri class

As of version 0.9.3, uri supplies a URI parser and builder. To use the parser, it’s as simple as supplying a string to the constructor:

using namespace boost::network;
uri::uri instance("");
std::cout << "scheme: " << instance.scheme() << std::endl
          << "host: " << << std::endl;

The command-line output of this program will be:

scheme: http

The uri builder

uri support a stream style syntax to create a URI from it’s elements. For example the program:

#include <iostream>
#include <boost/network/uri.hpp>
#include <boost/network/uri/uri_io.hpp>
using namespace boost::network;

int main() {
    uri::uri url;
    url << uri::scheme("http")
        << uri::host("")
        << uri::path("/cpp-netlib");
    std::cout << url << std::endl;
    return 0;

will output:

URI Concept


U:The URI type.
u,u_:An instance of M.
S:A string type.
s,v:An instance of S.
T:The Tag type.
Construct Result Description
U(u) Instance of U Copy constructible.
U(s) Instance of U Constructible from string.
u = u_; Reference to u Assignable.
u = s; Reference to u Assignable from string.
swap(u, u_); void Swappable.
scheme(u); Convertible to S Retrieve the URI scheme of u.
user_info(u); Convertible to S Retrieve the user info of u.
host(u); Convertible to S Retrieve the host of u.
port(u); Convertible to H Retrieve the port of u.
path(u); Convertible to S Retrieve the path of u.
query(u); Convertible to S Retrieve the query string of u.
fragment(u); Convertible to S Retrieve the fragment of u.

Table Of Contents

Previous topic

The message template

Next topic

HTTP implementation