<html><head><style>blockquote pre.programlisting { margin-left: 1em; padding-left: 1em; }
div.table { text-align: center; }
p.sidebar { background-color: #e0e0e0; font-style: italic; }
p.tablecaption { font-weight: bold; }
table { margin: auto; }</style><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>A Three-Class IP Address Proposal</title><meta name="generator" content="DocBook XSL Stylesheets V1.75.2"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><pre>Doc. no:  N3603
Date:     2013-03-17
Reply-To: Christopher Kohlhoff &lt;chris@kohlhoff.com&gt;
</pre>
<div class="chapter" title="A Three-Class IP Address Proposal"><div class="titlepage"><div><div><h2 class="title"><a name="ipaddress"></a>A Three-Class IP Address Proposal</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#ipaddress.overview">1. Overview</a></span></dt><dt><span class="section"><a href="#ipaddress.motivation_and_scope">2. Motivation and Scope</a></span></dt><dd><dl><dt><span class="section"><a href="#ipaddress.scope">2.1. Scope</a></span></dt><dt><span class="section"><a href="#ipaddress.target_audience">2.2. Target Audience</a></span></dt><dt><span class="section"><a href="#ipaddress.reference_implementation">2.3. Reference Implementation</a></span></dt></dl></dd><dt><span class="section"><a href="#ipaddress.impact_on_the_standard">3. Impact On the Standard</a></span></dt><dt><span class="section"><a href="#ipaddress.design_decisions">4. Design Decisions</a></span></dt><dd><dl><dt><span class="section"><a href="#ipaddress.a_version_independent_vocabulary_type">4.1. A Version-Independent Vocabulary Type</a></span></dt><dd><dl><dt><span class="section"><a href="#ipaddress.why_type_erasure_">4.1.1. Why Type Erasure?</a></span></dt></dl></dd><dt><span class="section"><a href="#ipaddress.version_specific_types">4.2. Version-Specific Types</a></span></dt><dt><span class="section"><a href="#ipaddress.two_classes_is_too_few">4.3. Two Classes is Too Few</a></span></dt><dt><span class="section"><a href="#ipaddress.namespace">4.4. Namespace</a></span></dt></dl></dd><dt><span class="section"><a href="#ipaddress.proposed_text">5. Proposed Text</a></span></dt><dd><dl><dt><span class="section"><a href="#definitions.definitions">5.1. Definitions</a></span></dt><dd><dl><dt><span class="section"><a href="#definitions.host_byte_order">5.1.1. host byte order</a></span></dt><dt><span class="section"><a href="#definitions.network_byte_order">5.1.2. network byte order</a></span></dt></dl></dd><dt><span class="section"><a href="#ipaddress.internet_protocol">5.2. Internet protocol addresses</a></span></dt><dd><dl><dt><span class="section"><a href="#headers.header____network___synopsis">5.2.1. Header <code class="literal">&lt;network&gt;</code> synopsis</a></span></dt><dt><span class="section"><a href="#classes.ip__address">5.2.2. Class <code class="literal">ip::address</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__ip__address__constructors">5.2.2.1. <code class="literal">ip::address</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__ip__address__assignment">5.2.2.2. <code class="literal">ip::address</code> assignment</a></span></dt><dt><span class="section"><a href="#classes.__ip__address__members">5.2.2.3. <code class="literal">ip::address</code> members</a></span></dt><dt><span class="section"><a href="#classes.__ip__address__static_members">5.2.2.4. <code class="literal">ip::address</code> static members</a></span></dt><dt><span class="section"><a href="#classes.__ip__address__comparisons">5.2.2.5. <code class="literal">ip::address</code> comparisons</a></span></dt><dt><span class="section"><a href="#classes.__ip__address__i_o">5.2.2.6. <code class="literal">ip::address</code> I/O</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.ip__address_v4">5.2.3. Class <code class="literal">ip::address_v4</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__ip__address_v4__constructors">5.2.3.1. <code class="literal">ip::address_v4</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__ip__address_v4__members">5.2.3.2. <code class="literal">ip::address_v4</code> members</a></span></dt><dt><span class="section"><a href="#classes.__ip__address_v4__static_members">5.2.3.3. <code class="literal">ip::address_v4</code> static members</a></span></dt><dt><span class="section"><a href="#classes.__ip__address_v4__comparisons">5.2.3.4. <code class="literal">ip::address_v4</code> comparisons</a></span></dt><dt><span class="section"><a href="#classes.__ip__address_v4__i_o">5.2.3.5. <code class="literal">ip::address_v4</code> I/O</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.ip__address_v6">5.2.4. Class <code class="literal">ip::address_v6</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__ip__address_v6__constructors">5.2.4.1. <code class="literal">ip::address_v6</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__ip__address_v6__members">5.2.4.2. <code class="literal">ip::address_v6</code> members</a></span></dt><dt><span class="section"><a href="#classes.__ip__address_v6__static_members">5.2.4.3. <code class="literal">ip::address_v6</code> static members</a></span></dt><dt><span class="section"><a href="#classes.__ip__address_v6__comparisons">5.2.4.4. <code class="literal">ip::address_v6</code> comparisons</a></span></dt><dt><span class="section"><a href="#classes.__ip__address_v6__i_o">5.2.4.5. <code class="literal">ip::address_v6</code> I/O</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.hash">5.2.5. Hash support</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="#ipaddress.acknowledgements">6. Acknowledgements</a></span></dt><dt><span class="section"><a href="#ipaddress.references">7. References</a></span></dt></dl></div><div class="section" title="1. Overview"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="ipaddress.overview"></a>1. Overview</h2></div></div></div><p>
      This proposal describes a three-class design for IP address classes:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          A vocabulary type, <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address</span></code>, for use in IP version independent
          code.
        </li><li class="listitem">
          An IPv4-specific type <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v4</span></code>.
        </li><li class="listitem">
          An IPv6-specific type <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v6</span></code>.
        </li></ul></div></div><div class="section" title="2. Motivation and Scope"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="ipaddress.motivation_and_scope"></a>2. Motivation and Scope</h2></div></div></div><div class="section" title="2.1. Scope"><div class="titlepage"><div><div><h3 class="title"><a name="ipaddress.scope"></a>2.1. Scope</h3></div></div></div><p>
        This proposal describes only types necessary to support the manipulation
        of IP (Internet Protocol) addresses. Other networking facilities, such as
        sockets and name resolution, are outside the scope of this proposal.
      </p></div><div class="section" title="2.2. Target Audience"><div class="titlepage"><div><div><h3 class="title"><a name="ipaddress.target_audience"></a>2.2. Target Audience</h3></div></div></div><p>
        The proposed interface is primarily intended for use by developers writing
        programs with a networking component, and in particular programs that utilise
        internet protocols such as TCP and UDP.
      </p></div><div class="section" title="2.3. Reference Implementation"><div class="titlepage"><div><div><h3 class="title"><a name="ipaddress.reference_implementation"></a>2.3. Reference Implementation</h3></div></div></div><p>
        This proposal is based on the IP address classes in the <a class="ulink" href="http://www.boost.org/libs/asio" target="_top">Boost.Asio</a>
        library. The proposed text is from <a class="ulink" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2175.pdf" target="_top">N2175</a>
        "Networking Library Proposal for TR2 (Revision 1)" with small modifications
        to reflect enhancements made to <a class="ulink" href="http://www.boost.org/libs/asio" target="_top">Boost.Asio</a>
        since 2007. At present, the proposed text does not differ significantly from
        the corresponding classes in <a class="ulink" href="http://www.boost.org/libs/asio" target="_top">Boost.Asio</a>.
      </p></div></div><div class="section" title="3. Impact On the Standard"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="ipaddress.impact_on_the_standard"></a>3. Impact On the Standard</h2></div></div></div><p>
      This is a pure library proposal. It does not add any new language features,
      nor does it alter any existing standard library headers.
    </p><p>
      This library can be implemented using compilers that conform to the C++11 standard.
      An implementation of this library requires operating system-specific functions
      that lie outside the C++11 standard.
    </p></div><div class="section" title="4. Design Decisions"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="ipaddress.design_decisions"></a>4. Design Decisions</h2></div></div></div><div class="section" title="4.1. A Version-Independent Vocabulary Type"><div class="titlepage"><div><div><h3 class="title"><a name="ipaddress.a_version_independent_vocabulary_type"></a>4.1. A Version-Independent Vocabulary Type</h3></div></div></div><p>
        Ideally, most network applications should be written so that they are independent
        of the IP version in use. For this reason, this proposal provides the <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address</span></code>
        class as a vocabulary type.
      </p><p>
        The characteristics of the <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address</span></code>
        class are as follows:
      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
            Uses type erasure. It may hold either an IPv4 or IPv6 address, but it
            preserves original type.
          </li><li class="listitem">
            May be used with <code class="computeroutput"><span class="identifier">AF_INET</span></code>
            or <code class="computeroutput"><span class="identifier">AF_INET6</span></code> sockets.
          </li><li class="listitem">
            May be converted to or from either an IPv4 address string or an IPv6
            address string. Automatically determines the correct underlying type.
          </li><li class="listitem">
            May be converted to or from an IPv4 or IPv6 address object of the corresponding
            version-specific class. ("To" assuming the version-independent
            source holds the correct underlying type.)
          </li><li class="listitem">
            Provides various operations, for testing and manipulating addresses,
            that apply to both IPv4 and IPv6.
          </li><li class="listitem">
            When default-constructed, initialises the <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address</span></code>
            object so that it corresponds to a default-constructed IPv4 address.
            (This particular value was chosen in <a class="ulink" href="http://www.boost.org/libs/asio" target="_top">Boost.Asio</a>
            as IPv6 networking support is not universal, and the value is also the
            smallest in terms of <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address</span><span class="special">::</span><span class="keyword">operator</span><span class="special">&lt;</span></code>.)
          </li></ul></div><p>
        In general, the <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address</span></code> interface is designed to provide
        just enough support to use IP addresses in version-independent networking
        contexts. When a program requires a facility that applies to only IPv4 or
        IPv6 addresses, the developer is expected to use one of the version-specific
        types described below.
      </p><div class="section" title="4.1.1. Why Type Erasure?"><div class="titlepage"><div><div><h4 class="title"><a name="ipaddress.why_type_erasure_"></a>4.1.1. Why Type Erasure?</h4></div></div></div><p>
          The question of whether to use a type-erased vocabulary type was discussed
          during the 2005 Boost review of <a class="ulink" href="http://www.boost.org/libs/asio" target="_top">Boost.Asio</a>.
          What was originally proposed was to distinguish IPv4 and IPv6 using separate
          types and to use template-based genericity to be version independent. This
          approach was rejected by the participants in the review.
        </p><p>
          The point is that most applications do indeed need to be version independent
          at runtime. For example:
        </p><pre class="programlisting">Usage: my_tcp_server &lt;bind_to_address&gt;

./my_tcp_server 0.0.0.0    # Binds to IPv4 wildcard address
./my_tcp_server 127.0.0.1  # Binds to specific IPv4 address
./my_tcp_server ::0        # Binds to IPv6 wildcard address
./my_tcp_server ::1        # Binds to specific IPv6 address
</pre><p>
          The implementation of <code class="literal">my_tcp_server</code> only deals in one
          type of address class. No templates are required.
        </p><p>
          Forcing all applications to create their own runtime switching was deemed
          infeasible. Dual-stack support is not universal and cannot be relied on
          for portable applications. Hence the current form in <a class="ulink" href="http://www.boost.org/libs/asio" target="_top">Boost.Asio</a>
          exists as a tradeoff between supporting the easy development of version-independent
          applications and the low level access for those who need it.
        </p></div></div><div class="section" title="4.2. Version-Specific Types"><div class="titlepage"><div><div><h3 class="title"><a name="ipaddress.version_specific_types"></a>4.2. Version-Specific Types</h3></div></div></div><p>
        The version-specific address classes, <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v4</span></code>
        and <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v6</span></code>, are provided for use cases
        where finer grained control is required, such as:
      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
            Reduced memory consumption. An application may need to store many addresses.
          </li><li class="listitem">
            Speed. A complex algorithm may deal with only a single type of address,
            and the cost of repeatedly extracting the underlying value from a type-erased
            type is prohibitive.
          </li><li class="listitem">
            Compile-time type safety. A programmer may wish to provide an interface
            that deals in only one particular IP version. Another may wish to provide
            different overloads of a function that are distinguished by IP version.
          </li></ul></div><p>
        The characteristics of the <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v4</span></code>
        class are as follows:
      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
            Specifically an IPv4 address.
          </li><li class="listitem">
            For use with <code class="computeroutput"><span class="identifier">AF_INET</span></code>
            sockets.
          </li><li class="listitem">
            May be converted to or from an IPv4-form address string (<code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">b</span><span class="special">.</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">d</span></code>). Rejects other string forms.
          </li><li class="listitem">
            May be converted to or from a 32 bit integer in host byte order. (Some
            applications use this for low level bit manipulation.)
          </li><li class="listitem">
            May be converted to or from a 32 bit integer / 4 byte array in network
            byte order. (E.g. if used for transmission when embedded within a network
            protocol.)
          </li><li class="listitem">
            Provides static member functions for creating well-known IPv4 addresses.
          </li><li class="listitem">
            Provides various other operations for testing and manipulating IPv4 addresses.
          </li></ul></div><p>
        The characteristics of the <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v6</span></code>
        class are as follows:
      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
            Specifically an IPv6 address.
          </li><li class="listitem">
            For use with <code class="computeroutput"><span class="identifier">AF_INET6</span></code>
            sockets.
          </li><li class="listitem">
            May be converted to or from an IPv6-form address string (<code class="computeroutput"><span class="identifier">abcd</span><span class="special">:</span><span class="identifier">efgh</span><span class="special">:...</span></code>,
            etc). Rejects other string forms.
          </li><li class="listitem">
            May be converted to or from a 128 bit integer / 16 byte array in network
            byte order. (E.g. again, if used for transmission.)
          </li><li class="listitem">
            May be explicitly created from an <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v4</span></code>,
            with the creation function determining which conversion is used (to v4-mapped
            or v4-compatible).
          </li><li class="listitem">
            May be explicitly converted to an <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v4</span></code>,
            if the address is one of the above v4 forms.
          </li><li class="listitem">
            Provides static member functions for creating well-known IPv6 addresses.
          </li><li class="listitem">
            Provides various other operations for testing and manipulating IPv6 addresses.
          </li></ul></div></div><div class="section" title="4.3. Two Classes is Too Few"><div class="titlepage"><div><div><h3 class="title"><a name="ipaddress.two_classes_is_too_few"></a>4.3. Two Classes is Too Few</h3></div></div></div><p>
        An alternative IP address design has been proposed that revolves around two
        classes. Using the naming conventions of this proposal, these classes would
        be:
      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
            A vocabulary type, <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address</span></code>,
            for use in IP version independent code. Unlike the three-class design,
            this class is also intended to represent IPv6 addresses.
          </li><li class="listitem">
            A version-specific type, <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v4</span></code>.
          </li></ul></div><p>
        This design appears to be driven by a desire to push people toward the version-independent
        type, but to still meet the space constraints of applications that must deal
        with large numbers of IPv4 addresses. The design is based on the notion that
        IPv4 addresses are a subset of IPv6 addresses, and that IPv4 addresses can
        be mapped, and stored, into IPv6.
      </p><p>
        The author rejects this design for a number of reasons.
      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
            It lacks symmetry and is potentially surprising to users.
          </li></ul></div><p>
        Superficially, the two-class design gives a special place to IPv4 addresses
        ("I can see the IPv4 class... but where's IPv6?").
      </p><p>
        What is more important, however, is that the design prevents a programmer
        from utilising the C++ type system to create efficient function overloads
        based on the IP version. A programmer can provide a function overload specifically
        for IPv4 addresses:
      </p><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">some_function</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">)</span>
<span class="special">{</span>
  <span class="special">...</span>
<span class="special">}</span>
</pre><p>
        but when it comes to supporting IPv6 addresses the programmer has no choice
        but to resort to runtime dispatching:
      </p><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">some_function</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ip</span><span class="special">::</span><span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">)</span>
<span class="special">{</span>
  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">a</span><span class="special">.</span><span class="identifier">is_v6</span><span class="special">())</span>
  <span class="special">{</span>
    <span class="special">...</span>
  <span class="special">}</span>
  <span class="keyword">else</span>
  <span class="special">{</span>
    <span class="special">...</span>
  <span class="special">}</span>
<span class="special">}</span>
</pre><p>
        There is no way for an programmer to express an interface that wants to deal
        only in IPv6 addresses.
      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
            It unnecessarily discards information.
          </li></ul></div><p>
        A pure IPv4 address is subtly different from one mapped into an IPv6 address.
        This ties into the question of the larger networking ecosystem, in particular
        how one might use the address classes in conjunction with sockets. For example:
      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
            <code class="computeroutput"><span class="string">"1.2.3.4"</span> <span class="special">-&gt;</span></code>
            <code class="computeroutput"><span class="identifier">AF_INET</span></code> socket
          </li><li class="listitem">
            <code class="computeroutput"><span class="string">"::ffff:1.2.3.4"</span> <span class="special">-&gt;</span></code> <code class="computeroutput"><span class="identifier">AF_INET6</span></code>
            with dual stack socket
          </li><li class="listitem">
            <code class="computeroutput"><span class="string">"fe80::...:12:34"</span> <span class="special">-&gt;</span></code> <code class="computeroutput"><span class="identifier">AF_INET6</span></code>
            with or without dual stack
          </li></ul></div><p>
        Things like dual stack support are far from universal and some IPv6 transition/portability
        guides recommend explicitly disabling dual stack support. The author does
        not think that standardized address classes should push people in one or
        other direction with respect to dual stack usage. Thus, it is important to
        preserve the original type of the IP address.
      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
            It treats IPv6 operations as a superset of IPv4 operations.
          </li></ul></div><p>
        As there is no separate type for IPv6, the vocabulary type <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address</span></code>
        must support all IPv6-related operations. Some of these operations may lack
        a meaningful implementation for IPv4 addresses, and so behave in quite different
        ways (e.g. fail). Note that some of these operations are outside the scope
        of standardization, i.e. they may be part of an application.
      </p></div><div class="section" title="4.4. Namespace"><div class="titlepage"><div><div><h3 class="title"><a name="ipaddress.namespace"></a>4.4. Namespace</h3></div></div></div><p>
        This proposal follows <a class="ulink" href="http://www.boost.org/libs/asio" target="_top">Boost.Asio</a>
        in the use of the namespace <code class="computeroutput"><span class="identifier">ip</span><span class="special">::</span></code>, rather than the prefix <code class="computeroutput"><span class="identifier">ip_</span></code>,
        for the address classes. This namespace is part of a wider taxonomy and encompasses
        other IP-related facilities, including:
      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
            Protocol classes (<code class="computeroutput"><span class="identifier">tcp</span></code>,
            <code class="computeroutput"><span class="identifier">udp</span></code> and <code class="computeroutput"><span class="identifier">icmp</span></code>).
          </li><li class="listitem">
            Socket option classes related to unicast and multicast.
          </li><li class="listitem">
            Classes and functions related to IP name resolution.
          </li></ul></div><p>
        The author notes that the abbreviation <a class="ulink" href="http://en.wikipedia.org/wiki/IP" target="_top">IP</a>
        is an overloaded term, even within computing. If backward compatibility was
        not a concern, he would instead prefer the namespace <code class="computeroutput"><span class="identifier">inet</span><span class="special">::</span></code>. This is consistent with <span class="emphasis"><em>POSIX</em></span>
        naming, as in <code class="computeroutput"><span class="identifier">AF_INET</span></code>, <code class="computeroutput"><span class="identifier">inet_ntop</span><span class="special">()</span></code>,
        etc. It is also unambiguously network related and so might be placed directly
        under the <code class="computeroutput"><span class="identifier">std</span></code> namespace,
        i.e. <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">inet</span></code>.
      </p></div></div><div class="section" title="5. Proposed Text"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="ipaddress.proposed_text"></a>5. Proposed Text</h2></div></div></div><div class="section" title="5.1. Definitions"><div class="titlepage"><div><div><h3 class="title"><a name="definitions.definitions"></a>5.1. Definitions</h3></div></div></div><div class="section" title="5.1.1. host byte order"><div class="titlepage"><div><div><h4 class="title"><a name="definitions.host_byte_order"></a>5.1.1. host byte order</h4></div></div></div><p>
          See <a class="ulink" href="http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap04.html#tag_04_08" target="_top">Host
          and Network Byte Orders</a>.
        </p></div><div class="section" title="5.1.2. network byte order"><div class="titlepage"><div><div><h4 class="title"><a name="definitions.network_byte_order"></a>5.1.2. network byte order</h4></div></div></div><p>
          See <a class="ulink" href="http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap04.html#tag_04_08" target="_top">Host
          and Network Byte Orders</a>.
        </p></div></div><div class="section" title="5.2. Internet protocol addresses"><div class="titlepage"><div><div><h3 class="title"><a name="ipaddress.internet_protocol"></a>5.2. Internet protocol addresses</h3></div></div></div><p>
        This clause describes components that C++ programs may use to manipulate
        IP addresses.
      </p><div class="section" title="5.2.1. Header &lt;network&gt; synopsis"><div class="titlepage"><div><div><h4 class="title"><a name="headers.header____network___synopsis"></a>5.2.1. Header <code class="literal">&lt;network&gt;</code> synopsis</h4></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">net</span> <span class="special">{</span>

    <span class="comment">// Internet protocol addresses:</span>

    <span class="keyword">namespace</span> <span class="identifier">ip</span> <span class="special">{</span>

      <span class="keyword">class</span> <a class="link" href="#classes.ip__address" title="5.2.2. Class ip::address">address</a><span class="special">;</span>

      <span class="comment">// address comparisons:</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;);</span>

      <span class="comment">// address I/O:</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Traits</span><span class="special">&gt;</span>
        <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span>
          <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;);</span>

      <span class="keyword">class</span> <a class="link" href="#classes.ip__address_v4" title="5.2.3. Class ip::address_v4">address_v4</a><span class="special">;</span>

      <span class="comment">// address_v4 comparisons:</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;);</span>

      <span class="comment">// address_v4 I/O:</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Traits</span><span class="special">&gt;</span>
        <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span>
          <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;);</span>

      <span class="keyword">class</span> <a class="link" href="#classes.ip__address_v6" title="5.2.4. Class ip::address_v6">address_v6</a><span class="special">;</span>

      <span class="comment">// address_v6 comparisons:</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;);</span>

      <span class="comment">// address_v6 I/O:</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Traits</span><span class="special">&gt;</span>
        <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span>
          <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;);</span>

    <span class="special">}</span> <span class="comment">// namespace ip</span>
  <span class="special">}</span> <span class="comment">// namespace net</span>

  <span class="comment">// <a class="link" href="#classes.hash" title="5.2.5. Hash support">hash support</a></span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">;</span>
  <span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">net</span><span class="special">::</span><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address</span><span class="special">&gt;;</span>
  <span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">net</span><span class="special">::</span><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v4</span><span class="special">&gt;;</span>
  <span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">net</span><span class="special">::</span><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v6</span><span class="special">&gt;;</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" title="5.2.2. Class ip::address"><div class="titlepage"><div><div><h4 class="title"><a name="classes.ip__address"></a>5.2.2. Class <code class="literal">ip::address</code></h4></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">net</span> <span class="special">{</span>
    <span class="keyword">namespace</span> <span class="identifier">ip</span> <span class="special">{</span>

      <span class="keyword">class</span> <span class="identifier">address</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// constructors:</span>
        <span class="identifier">address</span><span class="special">();</span>
        <span class="identifier">address</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
        <span class="identifier">address</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>

        <span class="comment">// assignment:</span>
        <span class="identifier">address</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
        <span class="identifier">address</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>

        <span class="comment">// members:</span>
        <span class="keyword">bool</span> <span class="identifier">is_unspecified</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_loopback</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_multicast</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_v4</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_v6</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="identifier">address_v4</span> <span class="identifier">to_v4</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="identifier">address_v6</span> <span class="identifier">to_v6</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">(</span><span class="identifier">error_code</span><span class="special">&amp;</span> <span class="identifier">ec</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>

        <span class="comment">// static members:</span>
        <span class="keyword">static</span> <span class="identifier">address</span> <span class="identifier">from_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">);</span>
        <span class="keyword">static</span> <span class="identifier">address</span> <span class="identifier">from_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">,</span> <span class="identifier">error_code</span><span class="special">&amp;</span> <span class="identifier">ec</span><span class="special">);</span>
      <span class="special">};</span>

      <span class="comment">// address comparisons:</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>

      <span class="comment">// address I/O:</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Traits</span><span class="special">&gt;</span>
        <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span>
          <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>

    <span class="special">}</span> <span class="comment">// namespace ip</span>
  <span class="special">}</span> <span class="comment">// namespace net</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><div class="section" title="5.2.2.1. ip::address constructors"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address__constructors"></a>5.2.2.1. <code class="literal">ip::address</code> constructors</h5></div></div></div><pre class="programlisting"><span class="identifier">address</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">address</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Postconditions:</em></span> The postconditions of this function
              are indicated in the table below.
            </p></blockquote></div><div class="table"><a name="idp9843168"></a><p class="title"><b>Table 1. address::address() effects</b></p><div class="table-contents"><table summary="address::address() effects" border="1"><colgroup><col><col></colgroup><thead><tr><th>
                    <p>
                      expression
                    </p>
                  </th><th>
                    <p>
                      value
                    </p>
                  </th></tr></thead><tbody><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">is_v4</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">true</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">is_v6</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">false</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">to_v4</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">address_v4</span><span class="special">()</span></code>
                    </p>
                  </td></tr></tbody></table></div></div><br class="table-break"><pre class="programlisting"><span class="identifier">address</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">address</span></code>, initialising it with the
              specified IP version 4 address.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Postconditions:</em></span> The postconditions of this function
              are indicated in the table below.
            </p></blockquote></div><div class="table"><a name="idp9868992"></a><p class="title"><b>Table 2. address::address(const address_v4&amp;) effects</b></p><div class="table-contents"><table summary="address::address(const address_v4&amp;) effects" border="1"><colgroup><col><col></colgroup><thead><tr><th>
                    <p>
                      expression
                    </p>
                  </th><th>
                    <p>
                      value
                    </p>
                  </th></tr></thead><tbody><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">is_v4</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">true</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">is_v6</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">false</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">to_v4</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">addr</span></code>
                    </p>
                  </td></tr></tbody></table></div></div><br class="table-break"><pre class="programlisting"><span class="identifier">address</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">address</span></code>, initialising it with the
              specified IP version 6 address.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Postconditions:</em></span> The postconditions of this function
              are indicated in the table below.
            </p></blockquote></div><div class="table"><a name="idp9894064"></a><p class="title"><b>Table 3. address::address(const address_v6&amp;) effects</b></p><div class="table-contents"><table summary="address::address(const address_v6&amp;) effects" border="1"><colgroup><col><col></colgroup><thead><tr><th>
                    <p>
                      expression
                    </p>
                  </th><th>
                    <p>
                      value
                    </p>
                  </th></tr></thead><tbody><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">is_v4</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">false</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">is_v6</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">true</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">to_v6</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">addr</span></code>
                    </p>
                  </td></tr></tbody></table></div></div><br class="table-break"></div><div class="section" title="5.2.2.2. ip::address assignment"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address__assignment"></a>5.2.2.2. <code class="literal">ip::address</code> assignment</h5></div></div></div><pre class="programlisting"><span class="identifier">address</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Assigns the specified IP version 4 address
              into an object of class <code class="computeroutput"><span class="identifier">address</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Postconditions:</em></span> The postconditions of this function
              are indicated in the table below.
            </p></blockquote></div><div class="table"><a name="idp9924368"></a><p class="title"><b>Table 4. address&amp; address::operator=(const address_v4&amp;) effects</b></p><div class="table-contents"><table summary="address&amp; address::operator=(const address_v4&amp;) effects" border="1"><colgroup><col><col></colgroup><thead><tr><th>
                    <p>
                      expression
                    </p>
                  </th><th>
                    <p>
                      value
                    </p>
                  </th></tr></thead><tbody><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">is_v4</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">true</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">is_v6</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">false</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">to_v4</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">addr</span></code>
                    </p>
                  </td></tr></tbody></table></div></div><br class="table-break"><pre class="programlisting"><span class="identifier">address</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Assigns the specified IP version 6 address
              into an object of class <code class="computeroutput"><span class="identifier">address</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Postconditions:</em></span> The postconditions of this function
              are indicated in the table below.
            </p></blockquote></div><div class="table"><a name="idp9953232"></a><p class="title"><b>Table 5. address&amp; address::operator=(const address_v6&amp;) effects</b></p><div class="table-contents"><table summary="address&amp; address::operator=(const address_v6&amp;) effects" border="1"><colgroup><col><col></colgroup><thead><tr><th>
                    <p>
                      expression
                    </p>
                  </th><th>
                    <p>
                      value
                    </p>
                  </th></tr></thead><tbody><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">is_v4</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">false</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">is_v6</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">true</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">to_v6</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">addr</span></code>
                    </p>
                  </td></tr></tbody></table></div></div><br class="table-break"></div><div class="section" title="5.2.2.3. ip::address members"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address__members"></a>5.2.2.3. <code class="literal">ip::address</code> members</h5></div></div></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_unspecified</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">is_v4</span><span class="special">()</span> <span class="special">?</span> <span class="identifier">to_v4</span><span class="special">().</span><span class="identifier">is_unspecified</span><span class="special">()</span>
              <span class="special">:</span> <span class="identifier">to_v6</span><span class="special">().</span><span class="identifier">is_unspecified</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_loopback</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">is_v4</span><span class="special">()</span> <span class="special">?</span> <span class="identifier">to_v4</span><span class="special">().</span><span class="identifier">is_loopback</span><span class="special">()</span>
              <span class="special">:</span> <span class="identifier">to_v6</span><span class="special">().</span><span class="identifier">is_loopback</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_multicast</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">is_v4</span><span class="special">()</span> <span class="special">?</span> <span class="identifier">to_v4</span><span class="special">().</span><span class="identifier">is_multicast</span><span class="special">()</span>
              <span class="special">:</span> <span class="identifier">to_v6</span><span class="special">().</span><span class="identifier">is_multicast</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_v4</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="keyword">true</span></code>
              if the object contains an IP version 4 address.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_v6</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="keyword">true</span></code>
              if the object contains an IP version 6 address.
            </p></blockquote></div><pre class="programlisting"><span class="identifier">address_v4</span> <span class="identifier">to_v4</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> The IP version 4 address contained by
              the object.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Throws:</em></span> <code class="computeroutput"><span class="identifier">bad_cast</span></code>
              if <code class="computeroutput"><span class="identifier">is_v4</span><span class="special">()</span></code>
              is false.
            </p></blockquote></div><pre class="programlisting"><span class="identifier">address_v6</span> <span class="identifier">to_v6</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> The IP version 6 address contained by
              the object.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Throws:</em></span> <code class="computeroutput"><span class="identifier">bad_cast</span></code>
              if <code class="computeroutput"><span class="identifier">is_v6</span><span class="special">()</span></code>
              is false.
            </p></blockquote></div><pre class="programlisting"><span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">(</span><span class="identifier">error_code</span><span class="special">&amp;</span> <span class="identifier">ec</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">is_v4</span><span class="special">()</span> <span class="special">?</span> <span class="identifier">to_v4</span><span class="special">().</span><span class="identifier">to_string</span><span class="special">(</span><span class="identifier">ec</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">to_v6</span><span class="special">().</span><span class="identifier">to_string</span><span class="special">(</span><span class="identifier">ec</span><span class="special">)</span></code>.
            </p></blockquote></div></div><div class="section" title="5.2.2.4. ip::address static members"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address__static_members"></a>5.2.2.4. <code class="literal">ip::address</code> static members</h5></div></div></div><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">address</span> <span class="identifier">from_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">);</span>
<span class="keyword">static</span> <span class="identifier">address</span> <span class="identifier">from_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">,</span> <span class="identifier">error_code</span><span class="special">&amp;</span> <span class="identifier">ec</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Converts a string representation of an
              address into an object of class <code class="computeroutput"><span class="identifier">address</span></code>,
              as if by calling: 
</p><pre class="programlisting"><span class="identifier">address</span> <span class="identifier">a</span><span class="special">;</span>
<span class="identifier">address_v6</span> <span class="identifier">v6a</span> <span class="special">=</span> <span class="identifier">address_v6</span><span class="special">::</span><span class="identifier">from_string</span><span class="special">(</span><span class="identifier">str</span><span class="special">,</span> <span class="identifier">ec</span><span class="special">);</span>
<span class="keyword">if</span> <span class="special">(!</span><span class="identifier">ec</span><span class="special">)</span>
  <span class="identifier">a</span> <span class="special">=</span> <span class="identifier">v6a</span><span class="special">;</span>
<span class="keyword">else</span>
<span class="special">{</span>
  <span class="identifier">address_v4</span> <span class="identifier">v4a</span> <span class="special">=</span> <span class="identifier">address_v4</span><span class="special">::</span><span class="identifier">from_string</span><span class="special">(</span><span class="identifier">str</span><span class="special">,</span> <span class="identifier">ec</span><span class="special">);</span>
  <span class="keyword">if</span> <span class="special">(!</span><span class="identifier">ec</span><span class="special">)</span>
    <span class="identifier">a</span> <span class="special">=</span> <span class="identifier">v4a</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">a</span></code>.
            </p></blockquote></div></div><div class="section" title="5.2.2.5. ip::address comparisons"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address__comparisons"></a>5.2.2.5. <code class="literal">ip::address</code> comparisons</h5></div></div></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">(</span><span class="identifier">a</span><span class="special">.</span><span class="identifier">is_v4</span><span class="special">()</span>
              <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">is_v4</span><span class="special">()</span> <span class="special">&amp;&amp;</span>
              <span class="identifier">a</span><span class="special">.</span><span class="identifier">to_v4</span><span class="special">()</span>
              <span class="special">==</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">to_v4</span><span class="special">())</span> <span class="special">||</span> <span class="special">(</span><span class="identifier">a</span><span class="special">.</span><span class="identifier">is_v6</span><span class="special">()</span> <span class="special">&amp;&amp;</span>
              <span class="identifier">b</span><span class="special">.</span><span class="identifier">is_v6</span><span class="special">()</span>
              <span class="special">&amp;&amp;</span> <span class="identifier">a</span><span class="special">.</span><span class="identifier">to_v6</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">to_v6</span><span class="special">())</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">!(</span><span class="identifier">a</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">)</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">(</span><span class="identifier">a</span><span class="special">.</span><span class="identifier">is_v4</span><span class="special">()</span>
              <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">is_v4</span><span class="special">()</span> <span class="special">&amp;&amp;</span>
              <span class="identifier">a</span><span class="special">.</span><span class="identifier">to_v4</span><span class="special">()</span>
              <span class="special">&lt;</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">to_v4</span><span class="special">())</span> <span class="special">||</span> <span class="special">(</span><span class="identifier">a</span><span class="special">.</span><span class="identifier">is_v6</span><span class="special">()</span> <span class="special">&amp;&amp;</span>
              <span class="identifier">b</span><span class="special">.</span><span class="identifier">is_v6</span><span class="special">()</span>
              <span class="special">&amp;&amp;</span> <span class="identifier">a</span><span class="special">.</span><span class="identifier">to_v6</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">to_v6</span><span class="special">())</span>
              <span class="special">||</span> <span class="special">(</span><span class="identifier">a</span><span class="special">.</span><span class="identifier">is_v4</span><span class="special">()</span>
              <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">is_v6</span><span class="special">())</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">b</span>
              <span class="special">&lt;</span> <span class="identifier">a</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">!(</span><span class="identifier">b</span> <span class="special">&lt;</span>
              <span class="identifier">a</span><span class="special">)</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">!(</span><span class="identifier">a</span> <span class="special">&lt;</span>
              <span class="identifier">b</span><span class="special">)</span></code>.
            </p></blockquote></div></div><div class="section" title="5.2.2.6. ip::address I/O"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address__i_o"></a>5.2.2.6. <code class="literal">ip::address</code> I/O</h5></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Traits</span><span class="special">&gt;</span>
  <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span>
    <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Outputs the string representation of
              the address to the stream, as if it were implemented as follows: 
</p><pre class="programlisting"><span class="identifier">error_code</span> <span class="identifier">ec</span><span class="special">;</span>
<span class="identifier">string</span> <span class="identifier">s</span> <span class="special">=</span> <span class="identifier">addr</span><span class="special">.</span><span class="identifier">to_string</span><span class="special">(</span><span class="identifier">ec</span><span class="special">);</span>
<span class="keyword">if</span> <span class="special">(</span><span class="identifier">ec</span><span class="special">)</span>
<span class="special">{</span>
  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">os</span><span class="special">.</span><span class="identifier">exceptions</span><span class="special">()</span> <span class="special">&amp;</span> <span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">failbit</span><span class="special">)</span>
    <span class="keyword">throw</span> <span class="identifier">system_error</span><span class="special">(</span><span class="identifier">ec</span><span class="special">);</span>
  <span class="keyword">else</span>
    <span class="identifier">os</span><span class="special">.</span><span class="identifier">setstate</span><span class="special">(</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">failbit</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">else</span>
  <span class="keyword">for</span> <span class="special">(</span><span class="identifier">string</span><span class="special">::</span><span class="identifier">iterator</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="identifier">i</span> <span class="special">!=</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
    <span class="identifier">os</span> <span class="special">&lt;&lt;</span> <span class="identifier">os</span><span class="special">.</span><span class="identifier">widen</span><span class="special">(*</span><span class="identifier">i</span><span class="special">);</span>
</pre><p>
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">os</span></code>.
            </p></blockquote></div></div></div><div class="section" title="5.2.3. Class ip::address_v4"><div class="titlepage"><div><div><h4 class="title"><a name="classes.ip__address_v4"></a>5.2.3. Class <code class="literal">ip::address_v4</code></h4></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">net</span> <span class="special">{</span>
    <span class="keyword">namespace</span> <span class="identifier">ip</span> <span class="special">{</span>

      <span class="keyword">class</span> <span class="identifier">address_v4</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// types:</span>
        <span class="keyword">typedef</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">char</span><span class="special">,</span> <span class="number">4</span><span class="special">&gt;</span> <span class="identifier">bytes_type</span><span class="special">;</span>

        <span class="comment">// constructors:</span>
        <span class="identifier">address_v4</span><span class="special">();</span>
        <span class="keyword">explicit</span> <span class="identifier">address_v4</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">bytes_type</span><span class="special">&amp;</span> <span class="identifier">bytes</span><span class="special">);</span>
        <span class="keyword">explicit</span> <span class="identifier">address_v4</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">val</span><span class="special">);</span>

        <span class="comment">// members:</span>
        <span class="keyword">bool</span> <span class="identifier">is_unspecified</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_loopback</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_class_a</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_class_b</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_class_c</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_multicast</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="identifier">bytes_type</span> <span class="identifier">to_bytes</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">to_ulong</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">(</span><span class="identifier">error_code</span><span class="special">&amp;</span> <span class="identifier">ec</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>

        <span class="comment">// static members:</span>
        <span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">from_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">);</span>
        <span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">from_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">,</span> <span class="identifier">error_code</span><span class="special">&amp;</span> <span class="identifier">ec</span><span class="special">);</span>
        <span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">any</span><span class="special">();</span>
        <span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">loopback</span><span class="special">();</span>
        <span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">broadcast</span><span class="special">();</span>
        <span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">broadcast</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">,</span>
          <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">mask</span><span class="special">);</span>
        <span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">netmask</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
      <span class="special">};</span>

      <span class="comment">// address_v4 comparisons:</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>

      <span class="comment">// address_v4 I/O:</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Traits</span><span class="special">&gt;</span>
        <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span>
          <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>

    <span class="special">}</span> <span class="comment">// namespace ip</span>
  <span class="special">}</span> <span class="comment">// namespace net</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><div class="section" title="5.2.3.1. ip::address_v4 constructors"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address_v4__constructors"></a>5.2.3.1. <code class="literal">ip::address_v4</code> constructors</h5></div></div></div><pre class="programlisting"><span class="identifier">address_v4</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">address_v4</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Postconditions:</em></span> The postconditions of this function
              are indicated in the table below.
            </p></blockquote></div><div class="table"><a name="idp10447856"></a><p class="title"><b>Table 6. address_v4::address_v4() effects</b></p><div class="table-contents"><table summary="address_v4::address_v4() effects" border="1"><colgroup><col><col></colgroup><thead><tr><th>
                    <p>
                      expression
                    </p>
                  </th><th>
                    <p>
                      value
                    </p>
                  </th></tr></thead><tbody><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">to_bytes</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="special">{</span><span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">}</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">to_ulong</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="number">0</span></code>
                    </p>
                  </td></tr></tbody></table></div></div><br class="table-break"><pre class="programlisting"><span class="identifier">address_v4</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">bytes_type</span><span class="special">&amp;</span> <span class="identifier">bytes</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">address_v4</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Requires:</em></span> Each element of the array <code class="computeroutput"><span class="identifier">bytes</span></code> is in the range <code class="computeroutput"><span class="special">[</span><span class="number">0</span><span class="special">,</span>
              <span class="number">0xFF</span><span class="special">]</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Throws:</em></span> <code class="computeroutput"><span class="identifier">out_of_range</span></code>
              if any element of the array <code class="computeroutput"><span class="identifier">bytes</span></code>
              is not in the range <code class="computeroutput"><span class="special">[</span><span class="number">0</span><span class="special">,</span> <span class="number">0xFF</span><span class="special">]</span></code>. [<span class="emphasis"><em>Note:</em></span> For implementations
              where <code class="computeroutput"><span class="identifier">UCHAR_MAX</span> <span class="special">==</span>
              <span class="number">0xFF</span></code>, no out-of-range detection
              is needed. &#8212;<span class="emphasis"><em>end note</em></span>]
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Postconditions:</em></span> The postconditions of this function
              are indicated in the table below.
            </p></blockquote></div><div class="table"><a name="idp10487008"></a><p class="title"><b>Table 7. address_v4::address_v4(const bytes_type&amp;) effects</b></p><div class="table-contents"><table summary="address_v4::address_v4(const bytes_type&amp;) effects" border="1"><colgroup><col><col></colgroup><thead><tr><th>
                    <p>
                      expression
                    </p>
                  </th><th>
                    <p>
                      value
                    </p>
                  </th></tr></thead><tbody><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">to_bytes</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      
</p><pre class="programlisting"><span class="special">{</span> <span class="identifier">bytes</span><span class="special">[</span><span class="number">0</span><span class="special">],</span> <span class="identifier">bytes</span><span class="special">[</span><span class="number">1</span><span class="special">],</span>
  <span class="identifier">bytes</span><span class="special">[</span><span class="number">2</span><span class="special">],</span> <span class="identifier">bytes</span><span class="special">[</span><span class="number">3</span><span class="special">]</span> <span class="special">}</span>
</pre><p>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">to_ulong</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      
</p><pre class="programlisting"><span class="special">(</span><span class="identifier">bytes</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="number">24</span><span class="special">)</span> <span class="special">|</span> <span class="special">(</span><span class="identifier">bytes</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="number">16</span><span class="special">)</span>
  <span class="special">|</span> <span class="special">(</span><span class="identifier">bytes</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="number">8</span><span class="special">)</span> <span class="special">|</span> <span class="identifier">bytes</span><span class="special">[</span><span class="number">3</span><span class="special">]</span>
</pre><p>
                    </p>
                  </td></tr></tbody></table></div></div><br class="table-break"><pre class="programlisting"><span class="identifier">address_v4</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">val</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">address_v4</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">val</span></code>
              is in the range <code class="computeroutput"><span class="special">[</span><span class="number">0</span><span class="special">,</span> <span class="number">0xFFFFFFFF</span><span class="special">]</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Throws:</em></span> <code class="computeroutput"><span class="identifier">out_of_range</span></code>
              if <code class="computeroutput"><span class="identifier">val</span></code> is not in the
              range <code class="computeroutput"><span class="special">[</span><span class="number">0</span><span class="special">,</span> <span class="number">0xFFFFFFFF</span><span class="special">]</span></code>. [<span class="emphasis"><em>Note:</em></span> For implementations
              where <code class="computeroutput"><span class="identifier">ULONG_MAX</span> <span class="special">==</span>
              <span class="number">0xFFFFFFFF</span></code>, no out-of-range detection
              is needed. &#8212;<span class="emphasis"><em>end note</em></span>]
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Postconditions:</em></span> The postconditions of this function
              are indicated in the table below.
            </p></blockquote></div><div class="table"><a name="idp10546544"></a><p class="title"><b>Table 8. address_v4::address_v4(unsigned long) effects</b></p><div class="table-contents"><table summary="address_v4::address_v4(unsigned long) effects" border="1"><colgroup><col><col></colgroup><thead><tr><th>
                    <p>
                      expression
                    </p>
                  </th><th>
                    <p>
                      value
                    </p>
                  </th></tr></thead><tbody><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">to_bytes</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      
</p><pre class="programlisting"><span class="special">{</span> <span class="special">(</span><span class="identifier">val</span> <span class="special">&gt;&gt;</span> <span class="number">24</span><span class="special">)</span> <span class="special">&amp;</span> <span class="number">0xFF</span><span class="special">,</span> <span class="special">(</span><span class="identifier">val</span> <span class="special">&gt;&gt;</span> <span class="number">16</span><span class="special">)</span> <span class="special">&amp;</span> <span class="number">0xFF</span><span class="special">,</span>
  <span class="special">(</span><span class="identifier">val</span> <span class="special">&gt;&gt;</span> <span class="number">8</span><span class="special">)</span>  <span class="special">&amp;</span> <span class="number">0xFF</span><span class="special">,</span> <span class="identifier">val</span> <span class="special">&amp;</span> <span class="number">0xFF</span> <span class="special">}</span>
</pre><p>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">to_ulong</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">val</span></code>
                    </p>
                  </td></tr></tbody></table></div></div><br class="table-break"></div><div class="section" title="5.2.3.2. ip::address_v4 members"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address_v4__members"></a>5.2.3.2. <code class="literal">ip::address_v4</code> members</h5></div></div></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_unspecified</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">to_ulong</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_loopback</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">(</span><span class="identifier">to_ulong</span><span class="special">()</span>
              <span class="special">&amp;</span> <span class="number">0xFF000000</span><span class="special">)</span> <span class="special">==</span> <span class="number">0x7F</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_class_a</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">(</span><span class="identifier">to_ulong</span><span class="special">()</span>
              <span class="special">&amp;</span> <span class="number">0x80000000</span><span class="special">)</span> <span class="special">==</span> <span class="number">0</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_class_b</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">(</span><span class="identifier">to_ulong</span><span class="special">()</span>
              <span class="special">&amp;</span> <span class="number">0xC0000000</span><span class="special">)</span> <span class="special">==</span> <span class="number">0x80000000</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_class_c</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">(</span><span class="identifier">to_ulong</span><span class="special">()</span>
              <span class="special">&amp;</span> <span class="number">0xE0000000</span><span class="special">)</span> <span class="special">==</span> <span class="number">0xC0000000</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_multicast</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">(</span><span class="identifier">to_ulong</span><span class="special">()</span>
              <span class="special">&amp;</span> <span class="number">0xF0000000</span><span class="special">)</span> <span class="special">==</span> <span class="number">0xE0000000</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">to_bytes</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A representation of the address in <a class="link" href="#definitions.network_byte_order" title="5.1.2. network byte order">network byte order</a>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">to_ulong</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A representation of the address in <a class="link" href="#definitions.host_byte_order" title="5.1.1. host byte order">host byte order</a>.
            </p></blockquote></div><pre class="programlisting"><span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">(</span><span class="identifier">error_code</span><span class="special">&amp;</span> <span class="identifier">ec</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Converts an address into a string representation,
              as if by <span class="emphasis"><em>POSIX</em></span> <a class="ulink" href="http://www.opengroup.org/onlinepubs/000095399/functions/inet_ntop.html" target="_top"><code class="computeroutput"><span class="identifier">inet_ntop</span><span class="special">()</span></code></a>
              when invoked with address family <code class="computeroutput"><span class="identifier">AF_INET</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> If successful, the string representation
              of the address. Otherwise <code class="computeroutput"><span class="identifier">string</span><span class="special">()</span></code>.
            </p></blockquote></div></div><div class="section" title="5.2.3.3. ip::address_v4 static members"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address_v4__static_members"></a>5.2.3.3. <code class="literal">ip::address_v4</code> static members</h5></div></div></div><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">from_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">);</span>
<span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">from_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">,</span> <span class="identifier">error_code</span><span class="special">&amp;</span> <span class="identifier">ec</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Converts a string representation of an
              address into a corresponding <code class="computeroutput"><span class="identifier">address_v4</span></code>
              value, as if by <span class="emphasis"><em>POSIX</em></span> <a class="ulink" href="http://www.opengroup.org/onlinepubs/000095399/functions/inet_pton.html" target="_top"><code class="computeroutput"><span class="identifier">inet_pton</span><span class="special">()</span></code></a>
              when invoked with address family <code class="computeroutput"><span class="identifier">AF_INET</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> If successful, an <code class="computeroutput"><span class="identifier">address_v4</span></code>
              value corresponding to the string <code class="computeroutput"><span class="identifier">str</span></code>.
              Otherwise <code class="computeroutput"><span class="identifier">address_v4</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">any</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">address_v4</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">loopback</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">address_v4</span><span class="special">(</span><span class="number">0x7F000001</span><span class="special">)</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">broadcast</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">address_v4</span><span class="special">(</span><span class="number">0xFFFFFFFF</span><span class="special">)</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">broadcast</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">mask</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">address_v4</span><span class="special">(</span><span class="identifier">addr</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span> <span class="special">|</span> <span class="special">~</span><span class="identifier">mask</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">())</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">address_v4</span> <span class="identifier">netmask</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              If <code class="computeroutput"><span class="identifier">addr</span><span class="special">.</span><span class="identifier">is_class_a</span><span class="special">()</span></code>
              is true, returns <code class="computeroutput"><span class="identifier">address_v4</span><span class="special">(</span><span class="number">0xFF000000</span><span class="special">)</span></code>. If <code class="computeroutput"><span class="identifier">addr</span><span class="special">.</span><span class="identifier">is_class_b</span><span class="special">()</span></code> is true, returns <code class="computeroutput"><span class="identifier">address_v4</span><span class="special">(</span><span class="number">0xFFFF0000</span><span class="special">)</span></code>. If <code class="computeroutput"><span class="identifier">addr</span><span class="special">.</span><span class="identifier">is_class_c</span><span class="special">()</span></code> is true, returns <code class="computeroutput"><span class="identifier">address_v4</span><span class="special">(</span><span class="number">0xFFFFFF00</span><span class="special">)</span></code>. Otherwise returns <code class="computeroutput"><span class="identifier">address_v4</span><span class="special">(</span><span class="number">0xFFFFFFFF</span><span class="special">)</span></code>.
            </p></blockquote></div></div><div class="section" title="5.2.3.4. ip::address_v4 comparisons"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address_v4__comparisons"></a>5.2.3.4. <code class="literal">ip::address_v4</code> comparisons</h5></div></div></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span> <span class="special">!=</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span> <span class="special">&gt;</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">to_ulong</span><span class="special">()</span></code>.
            </p></blockquote></div></div><div class="section" title="5.2.3.5. ip::address_v4 I/O"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address_v4__i_o"></a>5.2.3.5. <code class="literal">ip::address_v4</code> I/O</h5></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Traits</span><span class="special">&gt;</span>
  <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span>
    <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Outputs the string representation of
              the address to the stream, as if it were implemented as follows: 
</p><pre class="programlisting"><span class="identifier">error_code</span> <span class="identifier">ec</span><span class="special">;</span>
<span class="identifier">string</span> <span class="identifier">s</span> <span class="special">=</span> <span class="identifier">addr</span><span class="special">.</span><span class="identifier">to_string</span><span class="special">(</span><span class="identifier">ec</span><span class="special">);</span>
<span class="keyword">if</span> <span class="special">(</span><span class="identifier">ec</span><span class="special">)</span>
<span class="special">{</span>
  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">os</span><span class="special">.</span><span class="identifier">exceptions</span><span class="special">()</span> <span class="special">&amp;</span> <span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">failbit</span><span class="special">)</span>
    <span class="keyword">throw</span> <span class="identifier">system_error</span><span class="special">(</span><span class="identifier">ec</span><span class="special">);</span>
  <span class="keyword">else</span>
    <span class="identifier">os</span><span class="special">.</span><span class="identifier">setstate</span><span class="special">(</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">failbit</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">else</span>
  <span class="keyword">for</span> <span class="special">(</span><span class="identifier">string</span><span class="special">::</span><span class="identifier">iterator</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="identifier">i</span> <span class="special">!=</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
    <span class="identifier">os</span> <span class="special">&lt;&lt;</span> <span class="identifier">os</span><span class="special">.</span><span class="identifier">widen</span><span class="special">(*</span><span class="identifier">i</span><span class="special">);</span>
</pre><p>
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">os</span></code>.
            </p></blockquote></div></div></div><div class="section" title="5.2.4. Class ip::address_v6"><div class="titlepage"><div><div><h4 class="title"><a name="classes.ip__address_v6"></a>5.2.4. Class <code class="literal">ip::address_v6</code></h4></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">net</span> <span class="special">{</span>
    <span class="keyword">namespace</span> <span class="identifier">ip</span> <span class="special">{</span>

      <span class="keyword">class</span> <span class="identifier">address_v6</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// types:</span>
        <span class="keyword">typedef</span> <span class="identifier">array</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">char</span><span class="special">,</span> <span class="number">16</span><span class="special">&gt;</span> <span class="identifier">bytes_type</span><span class="special">;</span>

        <span class="comment">// constructors:</span>
        <span class="identifier">address_v6</span><span class="special">();</span>
        <span class="keyword">explicit</span> <span class="identifier">address_v6</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">bytes_type</span><span class="special">&amp;</span> <span class="identifier">bytes</span><span class="special">,</span>
                            <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">scope_id</span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span>

        <span class="comment">// members:</span>
        <span class="keyword">void</span> <span class="identifier">scope_id</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">id</span><span class="special">);</span>
        <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">scope_id</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_unspecified</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_loopback</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_multicast</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_link_local</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_site_local</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_v4_mapped</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_v4_compatible</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_multicast_node_local</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_multicast_link_local</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_multicast_site_local</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_multicast_org_local</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">is_multicast_global</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="identifier">bytes_type</span> <span class="identifier">to_bytes</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">(</span><span class="identifier">error_code</span><span class="special">&amp;</span> <span class="identifier">ec</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="identifier">address_v4</span> <span class="identifier">to_v4</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>

        <span class="comment">// static members:</span>
        <span class="keyword">static</span> <span class="identifier">address_v6</span> <span class="identifier">from_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">);</span>
        <span class="keyword">static</span> <span class="identifier">address_v6</span> <span class="identifier">from_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">,</span> <span class="identifier">error_code</span><span class="special">&amp;</span> <span class="identifier">ec</span><span class="special">);</span>
        <span class="keyword">static</span> <span class="identifier">address_v6</span> <span class="identifier">any</span><span class="special">();</span>
        <span class="keyword">static</span> <span class="identifier">address_v6</span> <span class="identifier">loopback</span><span class="special">();</span>
        <span class="keyword">static</span> <span class="identifier">address_v6</span> <span class="identifier">v4_mapped</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
        <span class="keyword">static</span> <span class="identifier">address_v6</span> <span class="identifier">v4_compatible</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
      <span class="special">};</span>

      <span class="comment">// address_v6 comparisons:</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>

      <span class="comment">// address_v6 I/O:</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Traits</span><span class="special">&gt;</span>
        <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span>
          <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>

    <span class="special">}</span> <span class="comment">// namespace ip</span>
  <span class="special">}</span> <span class="comment">// namespace net</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
          [<span class="emphasis"><em>Note:</em></span> The implementations of the functions <code class="computeroutput"><span class="identifier">is_unspecified</span></code>, <code class="computeroutput"><span class="identifier">is_loopback</span></code>,
          <code class="computeroutput"><span class="identifier">is_multicast</span></code>, <code class="computeroutput"><span class="identifier">is_link_local</span></code>, <code class="computeroutput"><span class="identifier">is_site_local</span></code>,
          <code class="computeroutput"><span class="identifier">is_v4_mapped</span></code>, <code class="computeroutput"><span class="identifier">is_v4_compatible</span></code>, <code class="computeroutput"><span class="identifier">is_multicast_node_local</span></code>,
          <code class="computeroutput"><span class="identifier">is_multicast_link_local</span></code>,
          <code class="computeroutput"><span class="identifier">is_multicast_site_local</span></code>,
          <code class="computeroutput"><span class="identifier">is_multicast_org_local</span></code>
          and <code class="computeroutput"><span class="identifier">is_multicast_global</span></code>
          are determined by [<a class="link" href="#ref-RFC4291">RFC4291</a>]. &#8212;<span class="emphasis"><em>end
          note</em></span>]
        </p><div class="section" title="5.2.4.1. ip::address_v6 constructors"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address_v6__constructors"></a>5.2.4.1. <code class="literal">ip::address_v6</code> constructors</h5></div></div></div><pre class="programlisting"><span class="identifier">address_v6</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">address_v6</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Postconditions:</em></span> The postconditions of this function
              are indicated in the table below.
            </p></blockquote></div><div class="table"><a name="idp11075856"></a><p class="title"><b>Table 9. address_v6::address_v6() effects</b></p><div class="table-contents"><table summary="address_v6::address_v6() effects" border="1"><colgroup><col><col></colgroup><thead><tr><th>
                    <p>
                      expression
                    </p>
                  </th><th>
                    <p>
                      value
                    </p>
                  </th></tr></thead><tbody><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">is_unspecified</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">true</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">scope_id</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="number">0</span></code>
                    </p>
                  </td></tr></tbody></table></div></div><br class="table-break"><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">address_v6</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">bytes_type</span><span class="special">&amp;</span> <span class="identifier">bytes</span><span class="special">,</span>
                    <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">scope_id</span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">address_v6</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Postconditions:</em></span> The postconditions of this function
              are indicated in the table below.
            </p></blockquote></div><div class="table"><a name="idp11101984"></a><p class="title"><b>Table 10. address_v6::address_v6() effects</b></p><div class="table-contents"><table summary="address_v6::address_v6() effects" border="1"><colgroup><col><col></colgroup><thead><tr><th>
                    <p>
                      expression
                    </p>
                  </th><th>
                    <p>
                      value
                    </p>
                  </th></tr></thead><tbody><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">to_bytes</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">bytes</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">scope_id</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">scope_id</span></code>
                    </p>
                  </td></tr></tbody></table></div></div><br class="table-break"></div><div class="section" title="5.2.4.2. ip::address_v6 members"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address_v6__members"></a>5.2.4.2. <code class="literal">ip::address_v6</code> members</h5></div></div></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">scope_id</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">id</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="identifier">scope_id</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">id</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">scope_id</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> The scope identifier associated with
              the address.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_unspecified</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A boolean indicating whether the <code class="computeroutput"><span class="identifier">address_v6</span></code> object represents an unspecified
              address, as if computed by the following method: 
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="keyword">return</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">1</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">2</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">3</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span>
    <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">4</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">5</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">6</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">7</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span>
    <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">8</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">9</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">10</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">11</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span>
    <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">12</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">13</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">14</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">15</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span><span class="special">;</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_loopback</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A boolean indicating whether the <code class="computeroutput"><span class="identifier">address_v6</span></code> object represents a loopback
              address, as if computed by the following method: 
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="keyword">return</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">1</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">2</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">3</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span>
    <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">4</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">5</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">6</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">7</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span>
    <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">8</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">9</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">10</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">11</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span>
    <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">12</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">13</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">14</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">15</span><span class="special">]</span> <span class="special">==</span> <span class="number">1</span><span class="special">;</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_multicast</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A boolean indicating whether the <code class="computeroutput"><span class="identifier">address_v6</span></code> object represents a multicast
              address, as if computed by the following method: 
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="keyword">return</span> <span class="identifier">b</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0xFF</span><span class="special">;</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_link_local</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A boolean indicating whether the <code class="computeroutput"><span class="identifier">address_v6</span></code> object represents a unicast
              link-local address, as if computed by the following method: 
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="keyword">return</span> <span class="identifier">b</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0xFE</span> <span class="special">&amp;&amp;</span> <span class="special">(</span><span class="identifier">b</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">&amp;</span> <span class="number">0xC0</span><span class="special">)</span> <span class="special">==</span> <span class="number">0x80</span><span class="special">;</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_site_local</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A boolean indicating whether the <code class="computeroutput"><span class="identifier">address_v6</span></code> object represents a unicast
              site-local address, as if computed by the following method: 
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="keyword">return</span> <span class="identifier">b</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0xFE</span> <span class="special">&amp;&amp;</span> <span class="special">(</span><span class="identifier">b</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">&amp;</span> <span class="number">0xC0</span><span class="special">)</span> <span class="special">==</span> <span class="number">0xC0</span><span class="special">;</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_v4_mapped</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A boolean indicating whether the <code class="computeroutput"><span class="identifier">address_v6</span></code> object represents an IPv4-mapped
              IPv6 address, as if computed by the following method: 
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="keyword">return</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">1</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">2</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">3</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span>
    <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">4</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">5</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">6</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">7</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span>
    <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">8</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">9</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">10</span><span class="special">]</span> <span class="special">==</span> <span class="number">0xFF</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">11</span><span class="special">]</span> <span class="special">==</span> <span class="number">0xFF</span><span class="special">;</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_v4_compatible</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A boolean indicating whether the <code class="computeroutput"><span class="identifier">address_v6</span></code> object represents an IPv4-compatible
              IPv6 address, as if computed by the following method: 
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="keyword">return</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">1</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">2</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">3</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span>
    <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">4</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">5</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">6</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">7</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span>
    <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">8</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span> <span class="number">9</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">10</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">b</span><span class="special">[</span><span class="number">11</span><span class="special">]</span> <span class="special">==</span> <span class="number">0</span>
    <span class="special">&amp;&amp;</span> <span class="special">!</span><span class="identifier">is_unspecified</span><span class="special">()</span> <span class="special">&amp;&amp;</span> <span class="special">!</span><span class="identifier">is_loopback</span><span class="special">();</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_multicast_node_local</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A boolean indicating whether the <code class="computeroutput"><span class="identifier">address_v6</span></code> object represents a multicast
              node-local address, as if computed by the following method: 
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="keyword">return</span> <span class="identifier">b</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0xFF</span> <span class="special">&amp;&amp;</span> <span class="special">(</span><span class="identifier">b</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">&amp;</span> <span class="number">0x0F</span><span class="special">)</span> <span class="special">==</span> <span class="number">0x01</span><span class="special">;</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_multicast_link_local</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A boolean indicating whether the <code class="computeroutput"><span class="identifier">address_v6</span></code> object represents a multicast
              link-local address, as if computed by the following method: 
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="keyword">return</span> <span class="identifier">b</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0xFF</span> <span class="special">&amp;&amp;</span> <span class="special">(</span><span class="identifier">b</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">&amp;</span> <span class="number">0x0F</span><span class="special">)</span> <span class="special">==</span> <span class="number">0x02</span><span class="special">;</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_multicast_site_local</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A boolean indicating whether the <code class="computeroutput"><span class="identifier">address_v6</span></code> object represents a multicast
              site-local address, as if computed by the following method: 
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="keyword">return</span> <span class="identifier">b</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0xFF</span> <span class="special">&amp;&amp;</span> <span class="special">(</span><span class="identifier">b</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">&amp;</span> <span class="number">0x0F</span><span class="special">)</span> <span class="special">==</span> <span class="number">0x05</span><span class="special">;</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_multicast_org_local</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A boolean indicating whether the <code class="computeroutput"><span class="identifier">address_v6</span></code> object represents a multicast
              organisation-local address, as if computed by the following method:
              
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="keyword">return</span> <span class="identifier">b</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0xFF</span> <span class="special">&amp;&amp;</span> <span class="special">(</span><span class="identifier">b</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">&amp;</span> <span class="number">0x0F</span><span class="special">)</span> <span class="special">==</span> <span class="number">0x08</span><span class="special">;</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">is_multicast_global</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A boolean indicating whether the <code class="computeroutput"><span class="identifier">address_v6</span></code> object represents a multicast
              organisation-local address, as if computed by the following method:
              
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="keyword">return</span> <span class="identifier">b</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">0xFF</span> <span class="special">&amp;&amp;</span> <span class="special">(</span><span class="identifier">b</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">&amp;</span> <span class="number">0x0F</span><span class="special">)</span> <span class="special">==</span> <span class="number">0x0E</span><span class="special">;</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">to_bytes</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> A representation of the address in <a class="link" href="#definitions.network_byte_order" title="5.1.2. network byte order">network byte order</a>.
            </p></blockquote></div><pre class="programlisting"><span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="identifier">string</span> <span class="identifier">to_string</span><span class="special">(</span><span class="identifier">error_code</span><span class="special">&amp;</span> <span class="identifier">ec</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Converts an address into a string representation.
              If <code class="computeroutput"><span class="identifier">scope_id</span><span class="special">()</span>
              <span class="special">==</span> <span class="number">0</span></code>,
              converts as if by <span class="emphasis"><em>POSIX</em></span> <a class="ulink" href="http://www.opengroup.org/onlinepubs/000095399/functions/inet_ntop.html" target="_top"><code class="computeroutput"><span class="identifier">inet_ntop</span><span class="special">()</span></code></a>
              when invoked with address family <code class="computeroutput"><span class="identifier">AF_INET6</span></code>.
              If <code class="computeroutput"><span class="identifier">scope_id</span><span class="special">()</span>
              <span class="special">!=</span> <span class="number">0</span></code>,
              the format is <span class="emphasis"><em><code class="computeroutput"><span class="identifier">address</span></code></em></span><code class="computeroutput"><span class="special">%</span></code><span class="emphasis"><em><code class="computeroutput"><span class="identifier">scope</span><span class="special">-</span><span class="identifier">id</span></code></em></span>,
              where <span class="emphasis"><em><code class="computeroutput"><span class="identifier">address</span></code></em></span>
              is the string representation of the equivalent address having <code class="computeroutput"><span class="identifier">scope_id</span><span class="special">()</span>
              <span class="special">==</span> <span class="number">0</span></code>,
              and <span class="emphasis"><em><code class="computeroutput"><span class="identifier">scope</span><span class="special">-</span><span class="identifier">id</span></code></em></span>
              is an implementation-defined string representation of the scope identifier.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> If successful, the string representation
              of the address. Otherwise <code class="computeroutput"><span class="identifier">string</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="identifier">address_v4</span> <span class="identifier">to_v4</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">is_v4_mapped</span><span class="special">()</span> <span class="special">||</span> <span class="identifier">is_v4_compatible</span><span class="special">()</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> An <code class="computeroutput"><span class="identifier">address_v4</span></code>
              object corresponding to the IPv4-mapped or IPv4 compatible IPv6 address,
              as if computed by the following method: 
</p><pre class="programlisting"><span class="identifier">bytes_type</span> <span class="identifier">v6b</span> <span class="special">=</span> <span class="identifier">to_bytes</span><span class="special">();</span>
<span class="identifier">address_v4</span><span class="special">::</span><span class="identifier">bytes_type</span> <span class="identifier">v4b</span> <span class="special">=</span> <span class="special">{</span> <span class="identifier">v6b</span><span class="special">[</span><span class="number">12</span><span class="special">],</span> <span class="identifier">v6b</span><span class="special">[</span><span class="number">13</span><span class="special">],</span> <span class="identifier">v6b</span><span class="special">[</span><span class="number">14</span><span class="special">],</span> <span class="identifier">v6b</span><span class="special">[</span><span class="number">15</span><span class="special">]</span> <span class="special">};</span>
<span class="keyword">return</span> <span class="identifier">address_v4</span><span class="special">(</span><span class="identifier">v4b</span><span class="special">);</span>
</pre><p>
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Throws:</em></span> <code class="computeroutput"><span class="identifier">bad_cast</span></code>
              if <code class="computeroutput"><span class="identifier">is_v4_mapped</span><span class="special">()</span></code>
              is <code class="computeroutput"><span class="keyword">false</span></code> and <code class="computeroutput"><span class="identifier">is_v4_compatible</span><span class="special">()</span></code>
              is <code class="computeroutput"><span class="keyword">false</span></code>.
            </p></blockquote></div></div><div class="section" title="5.2.4.3. ip::address_v6 static members"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address_v6__static_members"></a>5.2.4.3. <code class="literal">ip::address_v6</code> static members</h5></div></div></div><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">address_v6</span> <span class="identifier">from_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">);</span>
<span class="keyword">static</span> <span class="identifier">address_v6</span> <span class="identifier">from_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">,</span> <span class="identifier">error_code</span><span class="special">&amp;</span> <span class="identifier">ec</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Converts a string representation of an
              address into a corresponding <code class="computeroutput"><span class="identifier">address_v6</span></code>
              value. The format is either <span class="emphasis"><em><code class="computeroutput"><span class="identifier">address</span></code></em></span>
              or <span class="emphasis"><em><code class="computeroutput"><span class="identifier">address</span></code></em></span><code class="computeroutput"><span class="special">%</span></code><span class="emphasis"><em><code class="computeroutput"><span class="identifier">scope</span><span class="special">-</span><span class="identifier">id</span></code></em></span>,
              where <span class="emphasis"><em><code class="computeroutput"><span class="identifier">address</span></code></em></span>
              is in the format specified by <span class="emphasis"><em>POSIX</em></span> <a class="ulink" href="http://www.opengroup.org/onlinepubs/000095399/functions/inet_pton.html" target="_top"><code class="computeroutput"><span class="identifier">inet_pton</span><span class="special">()</span></code></a>
              when invoked with address family <code class="computeroutput"><span class="identifier">AF_INET6</span></code>,
              and <span class="emphasis"><em><code class="computeroutput"><span class="identifier">scope</span><span class="special">-</span><span class="identifier">id</span></code></em></span>
              is an optional string specifying the scope identifier. All implementations
              shall accept as <span class="emphasis"><em><code class="computeroutput"><span class="identifier">scope</span><span class="special">-</span><span class="identifier">id</span></code></em></span>
              a string representation of an unsigned decimal integer. It is implementation-defined
              whether alternative scope identifier representations are permitted.
              If <span class="emphasis"><em><code class="computeroutput"><span class="identifier">scope</span><span class="special">-</span><span class="identifier">id</span></code></em></span>
              is not supplied, an <code class="computeroutput"><span class="identifier">address_v6</span></code>
              object shall be returned such that <code class="computeroutput"><span class="identifier">scope_id</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span></code>.
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> If successful, an <code class="computeroutput"><span class="identifier">address_v6</span></code>
              value corresponding to the string <code class="computeroutput"><span class="identifier">str</span></code>.
              Otherwise returns <code class="computeroutput"><span class="identifier">address_v6</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">address_v6</span> <span class="identifier">any</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">address_v6</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">address_v6</span> <span class="identifier">loopback</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> An address <code class="computeroutput"><span class="identifier">a</span></code>
              such that the condition <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">is_loopback</span><span class="special">()</span></code> holds.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">address_v6</span> <span class="identifier">v4_mapped</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> An <code class="computeroutput"><span class="identifier">address_v6</span></code>
              object containing the IPv4-mapped IPv6 address corresponding to the
              specified IPv4 address, as if computed by the following method: 
</p><pre class="programlisting"><span class="identifier">address_v4</span><span class="special">::</span><span class="identifier">bytes_type</span> <span class="identifier">v4b</span> <span class="special">=</span> <span class="identifier">addr</span><span class="special">.</span><span class="identifier">to_bytes</span><span class="special">();</span>
<span class="identifier">bytes_type</span> <span class="identifier">v6b</span> <span class="special">=</span> <span class="special">{</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span>
                   <span class="number">0xFF</span><span class="special">,</span> <span class="number">0xFF</span><span class="special">,</span> <span class="identifier">v4b</span><span class="special">[</span><span class="number">0</span><span class="special">],</span> <span class="identifier">v4b</span><span class="special">[</span><span class="number">1</span><span class="special">],</span> <span class="identifier">v4b</span><span class="special">[</span><span class="number">2</span><span class="special">],</span> <span class="identifier">v4b</span><span class="special">[</span><span class="number">3</span><span class="special">]</span> <span class="special">};</span>
<span class="keyword">return</span> <span class="identifier">address_v6</span><span class="special">(</span><span class="identifier">v6b</span><span class="special">);</span>
</pre><p>
            </p></blockquote></div><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">address_v6</span> <span class="identifier">v4_compatible</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v4</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> An <code class="computeroutput"><span class="identifier">address_v6</span></code>
              object containing the IPv4-compatible IPv6 address corresponding to
              the specified IPv4 address, as if computed by the following method:
              
</p><pre class="programlisting"><span class="identifier">address_v4</span><span class="special">::</span><span class="identifier">bytes_type</span> <span class="identifier">v4b</span> <span class="special">=</span> <span class="identifier">addr</span><span class="special">.</span><span class="identifier">to_bytes</span><span class="special">();</span>
<span class="identifier">bytes_type</span> <span class="identifier">v6b</span> <span class="special">=</span> <span class="special">{</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span>
                   <span class="identifier">v4b</span><span class="special">[</span><span class="number">0</span><span class="special">],</span> <span class="identifier">v4b</span><span class="special">[</span><span class="number">1</span><span class="special">],</span> <span class="identifier">v4b</span><span class="special">[</span><span class="number">2</span><span class="special">],</span> <span class="identifier">v4b</span><span class="special">[</span><span class="number">3</span><span class="special">]</span> <span class="special">};</span>
<span class="keyword">return</span> <span class="identifier">address_v6</span><span class="special">(</span><span class="identifier">v6b</span><span class="special">);</span>
</pre><p>
            </p></blockquote></div></div><div class="section" title="5.2.4.4. ip::address_v6 comparisons"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address_v6__comparisons"></a>5.2.4.4. <code class="literal">ip::address_v6</code> comparisons</h5></div></div></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">to_bytes</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">to_bytes</span><span class="special">()</span>
              <span class="special">&amp;&amp;</span> <span class="identifier">a</span><span class="special">.</span><span class="identifier">scope_id</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">scope_id</span><span class="special">()</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">!(</span><span class="identifier">a</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">)</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">to_bytes</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">to_bytes</span><span class="special">()</span>
              <span class="special">||</span> <span class="special">(!(</span><span class="identifier">b</span><span class="special">.</span><span class="identifier">to_bytes</span><span class="special">()</span>
              <span class="special">&lt;</span> <span class="identifier">a</span><span class="special">.</span><span class="identifier">to_bytes</span><span class="special">())</span> <span class="special">&amp;&amp;</span>
              <span class="identifier">a</span><span class="special">.</span><span class="identifier">scope_id</span><span class="special">()</span>
              <span class="special">&lt;</span> <span class="identifier">b</span><span class="special">.</span><span class="identifier">scope_id</span><span class="special">())</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">b</span>
              <span class="special">&lt;</span> <span class="identifier">a</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">!(</span><span class="identifier">b</span> <span class="special">&lt;</span>
              <span class="identifier">a</span><span class="special">)</span></code>.
            </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">!(</span><span class="identifier">a</span> <span class="special">&lt;</span>
              <span class="identifier">b</span><span class="special">)</span></code>.
            </p></blockquote></div></div><div class="section" title="5.2.4.5. ip::address_v6 I/O"><div class="titlepage"><div><div><h5 class="title"><a name="classes.__ip__address_v6__i_o"></a>5.2.4.5. <code class="literal">ip::address_v6</code> I/O</h5></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CharT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Traits</span><span class="special">&gt;</span>
  <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span>
    <span class="identifier">basic_ostream</span><span class="special">&lt;</span><span class="identifier">CharT</span><span class="special">,</span> <span class="identifier">Traits</span><span class="special">&gt;&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">address_v6</span><span class="special">&amp;</span> <span class="identifier">addr</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Effects:</em></span> Outputs the string representation of
              the address to the stream, as if it were implemented as follows: 
</p><pre class="programlisting"><span class="identifier">error_code</span> <span class="identifier">ec</span><span class="special">;</span>
<span class="identifier">string</span> <span class="identifier">s</span> <span class="special">=</span> <span class="identifier">addr</span><span class="special">.</span><span class="identifier">to_string</span><span class="special">(</span><span class="identifier">ec</span><span class="special">);</span>
<span class="keyword">if</span> <span class="special">(</span><span class="identifier">ec</span><span class="special">)</span>
<span class="special">{</span>
  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">os</span><span class="special">.</span><span class="identifier">exceptions</span><span class="special">()</span> <span class="special">&amp;</span> <span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">failbit</span><span class="special">)</span>
    <span class="keyword">throw</span> <span class="identifier">system_error</span><span class="special">(</span><span class="identifier">ec</span><span class="special">);</span>
  <span class="keyword">else</span>
    <span class="identifier">os</span><span class="special">.</span><span class="identifier">setstate</span><span class="special">(</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">failbit</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">else</span>
  <span class="keyword">for</span> <span class="special">(</span><span class="identifier">string</span><span class="special">::</span><span class="identifier">iterator</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="identifier">i</span> <span class="special">!=</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
    <span class="identifier">os</span> <span class="special">&lt;&lt;</span> <span class="identifier">os</span><span class="special">.</span><span class="identifier">widen</span><span class="special">(*</span><span class="identifier">i</span><span class="special">);</span>
</pre><p>
            </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
              <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">os</span></code>.
            </p></blockquote></div></div></div><div class="section" title="5.2.5. Hash support"><div class="titlepage"><div><div><h4 class="title"><a name="classes.hash"></a>5.2.5. Hash support</h4></div></div></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">net</span><span class="special">::</span><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">net</span><span class="special">::</span><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v4</span><span class="special">&gt;;</span>
<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">net</span><span class="special">::</span><span class="identifier">ip</span><span class="special">::</span><span class="identifier">address_v6</span><span class="special">&gt;;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> the template specializations shall meet
            the requirements of class template <code class="computeroutput"><span class="identifier">hash</span></code>
            (C++11 [unord.hash]).
          </p></blockquote></div></div></div></div><div class="section" title="6. Acknowledgements"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="ipaddress.acknowledgements"></a>6. Acknowledgements</h2></div></div></div><p>
      The author would like to thank Arash Partow, Jamie Allsop and James Anderson
      for their feedback and suggestions.
    </p></div><div class="section" title="7. References"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="ipaddress.references"></a>7. References</h2></div></div></div><p>
      <a name="ref-RFC4291"></a>[RFC4291] Hinden, R. and Deering, S., <span class="emphasis"><em>RFC
      4291: Internet Protocol Version 6 (IPv6) Addressing Architecture</em></span>,
      2006, <a class="ulink" href="http://www.ietf.org/rfc/rfc4291.txt" target="_top">http://www.ietf.org/rfc/rfc4291.txt</a>.
    </p></div></div></body></html>
