/**
 *  @brief  A specialization of vector for booleans which offers fixed time
 *  access to individual elements in any order.
 *
 *  Note that vector<bool> does not actually meet the requirements for being
 *  a container.  This is because the reference and pointer types are not
 *  really references and pointers to bool.  See DR96 for details.  @see
 *  vector for function documentation.
 *
 *  @ingroup Containers
 *  @ingroup Sequences
 *
 *  In some terminology a %vector can be described as a dynamic
 *  C-style array, it offers fast and efficient access to individual
 *  elements in any order and saves the user from worrying about
 *  memory and size allocation.  Subscripting ( @c [ ] ) access is
 *  also provided as with C-style arrays.
 */
template<typename _Alloc>
class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
{
    // XXX: real declaration.
}

vector<bool> c;
bool* p = &c[0];

yyc@TDesk run > udisksctl mount -b /dev/sdc1
==== AUTHENTICATING FOR org.freedesktop.udisks2.filesystem-mount-other-seat ===
挂载 Generic Mass-Storage (/dev/sdc1) 需要身份验证
Authenticating as: root
password:
==== AUTHENTICATION COMPLETE ===
Mounted /dev/sdc1 at /run/media/yyc/3139-3239.

<?xml version="1.0" encoding="utf-8"?>
<action id="org.freedesktop.udisks2.filesystem-mount-other-seat">
    <description>Mount a filesystem from a device plugged into another seat</description>
    <description xml:lang="zh_CN">挂载插入另一槽位设备上的文件系统</description>
    <message>Authentication is required to mount the filesystem</message>
    <message xml:lang="zh_CN">挂载文件系统需要身份验证</message>
    <defaults>
        <allow_any>yes</allow_any>
        <allow_inactive>yes</allow_inactive>
        <allow_active>yes</allow_active>
    </defaults>
</action>

class Widget;
vector<Widget> vw;

vector<Widget>(vw).swap(vw);

#include <vector>
#include <iostream>
#include <time.h>
#include <stdlib.h>
#include <fstream>
#include <iterator>

using namespace std;

const int MAX = 1024;

#define show(v, msg)    printf ("%s -- %s: size: %lu, capacity: %lu\n", \
                                #v, msg, v.size(), v.capacity());

int main(int argc, char *argv[])
{
    srand(time(NULL));

    printf("Testing vector...\n");
    vector<int> v;
    show(v, "After init");

    v.reserve(MAX);
    show(v, "After reserve()");

    for (int i = 0; i < MAX; ++i)
    {
        v.push_back(random()%1000);
    }
    show(v, "After Filling");

    v.erase(remove_if(v.begin(), v.end(), [](int x){return x > 100;}), v.end());
    show(v, "After erase()");

    vector<int>(v).swap(v);
    show(v, "After swap()");

    v.clear();
    show(v, "after clear");

    vector<int>().swap(v);
    show(v, "after swap with empty vector");

    return 0;
}

Testing vector...
v -- After init: size: 0, capacity: 0
v -- After reserve(): size: 0, capacity: 1024
v -- After Filling: size: 1024, capacity: 1024
v -- After erase(): size: 106, capacity: 1024
v -- After swap(): size: 106, capacity: 106
v -- after clear: size: 0, capacity: 106
v -- after swap with empty vector: size: 0, capacity: 0
Program ended with exit code: 0

 1: // Legacy C API.
 2: extern void doSomething(const int* pInts, size_t numInts);
 3: 
 4: vector<int> v;
 5: // ...
 6: // Operations on v.
 7: // ...
 8: 
 9: if (!v.empty())
10: {
11:     doSomething(&v[0], v.size());
12: }

&*v.begin() == &v[0]

13: // Legacy C API:
14: extern void doSomething(const char* str);
15: 
16: string ss;
17: // ...
18: // Do something with ss
19: // ...
20: 
21: doSomething(ss.c_str());

// C API: this function takes a pointer to an array of at most arraySize
// doubles and writes data to it. It returns the number of doubles written,
// which is never more than maxNumDoubles.
size_t fillArray(double *pArray, size_t arraySize);

vector<double> vd;
vd.reserve(maxNumDoubles);
vd.resize(fillArray(&vd[0], maxNumDoubles))

vector<double> vd(maxNumDouble);
vd.resize(fillArray(&vd[0], vd.size()));

// C API: this function takes a pointer to an array of at most arraySize
// chars and writes data to it. It returns the number of chars written,
// which is never more than maxNumChars.

size_t fillString(char* pArray, size_t arraySize);

vector<char> vc(maxNumChars);
size_t charsWritten = fillString(&vc[0], vc.size());
string s(vc.begin(), vc.begin()+charsWritten));

size_t doSomething(int* pints, size_t numInts); // C API to initialize int array.
vector<int> v(maxNumInts); // This is media
size_t sz = doSomething(&v[0], v.size());
set<int> intSet(v.begin(), v.begin()+sz);

vector<int> v;
for (int i = 1; i < 1001; ++i)
{
    v.push_back(i)
}

vector<int> v;
v.reserve(1000);
for (int i = 1; i < 1001; ++i)
{
    v.push_back(i)
}

#include <vector>
#include <stdio.h>
using namespace std;

int main(int argc, char *argv[])
{
    vector<char> ss;
    char c = 'a';
    while (c < 'z') {
        ss.push_back(c);
        c++;
    }

    char* p = ss.data();
    fprintf(stderr, "p = %s\n",p);
    return 0;
}

~/tmp $ g++ test.cpp -o test
~/tmp $ ./test
p = abcdefghijklmnopqrstuvwxy

1: auto_ptr<int> p1(new int(1));
2: auto_ptr<int> p2(p1);
3: p1 = p2;