#include <iostream>    // 预处理器编译指令#include

int main() {
    using namespace std;

    cout << "Come up and C++ me some time";
    cout << endl;
    cout << "You won't regret it!" << endl;

    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    int carrots;
    carrots = ;
    cout << "I have ";
    cout << carrots;
    cout << " carrots.";
    cout << endl;
    carrots = carrots - ;
    cout << "Crunch, crunch. Now I have " << carrots << " carrots." << endl;

    cin.get();
    ;
}

#include <iostream>

int main() {
    using namespace std;

    int carrots;

    cout << "How many carrots do you have?" << endl;
    cin >> carrots;
    cout << "Here are two more.";
    carrots = carrots + ;
    cout << "Now you have " << carrots << " carrots." << endl;

    cin.get();
    cin.get();
    ;
}

#include <iostream>
#include <cmath>

int main() {
    using namespace std;

    double area;
    cout << "Enter the floor area,in square feet,of your home: ";
    cin >> area;
    double side;
    side = sqrt(area);
    cout << "That's the equivalent of a square " << side
        << " feet to the side." << endl;
    cout << "How fascinating!" << endl;

    cin.get();
    cin.get();
    ;
}

#include <iostream>

void simon(int);

int main() {
    using namespace std;

    simon();
    cout << "Pick an integer: ";
    int count;
    cin >> count;
    simon(count);
    cout << "Done!" << endl;

    cin.get();
    cin.get();
    ;
}

void simon(int n) {
    using namespace std;
    cout << "Simon says touch your toes " << n << " times." << endl;
}

#include <iostream>

int stonetolb(int);

int main() {
    using namespace std;
    int stone;
    cout << "Enter the weight in stone: ";
    cin >> stone;
    int pounds = stonetolb(stone);
    cout << stone << " stone = ";
    cout << pounds << " pounds." << endl;

    cin.get();
    cin.get();

    ;
}

int stonetolb(int sts) {
     * sts;
}

#include <iostream>
#include <climits>

int main() {
    using namespace std;

    int n_int = INT_MAX;
    short n_short = SHRT_MAX;
    long n_long = LONG_MAX;
    long long n_llong = LLONG_MAX;

    cout << "int is " << sizeof(int) << " bytes." << endl;
    cout << "short is " << sizeof n_short << " bytes." << endl;
    cout << "long is " << sizeof n_long << " bytes." << endl;
    cout << "long long is " << sizeof n_llong << " bytes." << endl;
    cout << endl;

    cout << "Maximum values:" << endl;
    cout << "int: " << n_int << endl;
    cout << "short: " << n_short << endl;
    cout << "long: " << n_long << endl;
    cout << "long long: " << n_llong << endl << endl;
    cout << "Minimum value = " << INT_MIN << endl;
    cout << "Bits per byte = " << CHAR_BIT << endl;

    cin.get();

    ;
}

#include <iostream>
#define ZERO 0
#include <climits>

int main() {
    using namespace std;
    short sam = SHRT_MAX;
    unsigned short sue = sam;

    cout << "Sam has " << sam << " dollars and Sue has " << sue;
    cout << " dollars deposited." << endl
        << "Add $1 to each account." << endl << "Now ";
    sam = sam + ;
    sue = sue + ;
    cout << "Sam has " << sam << " dollars and Sue has " << sue;
    cout << " dollars deposited.\nPoor Sam!" << endl;
    sam = ZERO;
    sue = ZERO;
    cout << "Sam has " << sam << " dollars and Sue has " << sue;
    cout << " dollars deposited." << endl;
    cout << "Take $1 from each account." << endl << "Now ";
    sam = sam - ;
    sue = sue - ;
    cout << "Sam has " << sam << " dollars and Sue has " << sue;
    cout << " dollars deposited." << endl << "Lucky Sue!" << endl;

    cin.get();
    ;
}

#include <iostream>

int main() {
    using namespace std;

    ;
    int waist = 0x42;
    ;

    cout << "Monsieur cuts a striking figure!\n";
    cout << "chest = " << chest << " (42 in decimal)\n";
    cout << "waist = " << waist << " (0x42 in hex)\n";
    cout << "inseam = " << inseam << " (042 in octal)\n";

    cin.get();
    ;
}

#include <iostream>

int main() {
    using namespace std;

    ;
    ;
    ;

    cout << "Monsieur cuts a striking figure!" << endl;
    cout << "chest = " << chest << " (decimal for 42)" << endl;
    cout << hex;
    cout << "waist = " << waist << " (hexadecimal for 42)" << endl;
    cout << oct;
    cout << "inseam = " << inseam << " (octal for 42)" << endl;

    cin.get();
    ;
}

#include <iostream>

int main() {
    using namespace std;

    char ch;

    cout << "Enter a character: " << endl;
    cin >> ch;
    cout << "Hola! ";
    cout << "Thank you for the " << ch << " character." << endl;

    cin.get();
    cin.get();
    ;
}

#include <iostream>

int main() {
    using namespace std;

    char ch = 'M';
    int i = ch;
    cout << "The ASCII code for " << ch << " is " << i << endl;
    cout << "Add one to the character code:" << endl;

    ch = ch + ;
    i = ch;
    cout << "The ASCII code for " << ch << " is " << i << endl;

    cout << "Displaying char ch using cout.put(ch): ";
    cout.put(ch);

    cout.put('!');
    cout << endl << "Done" << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    cout.setf(ios_base::fixed, ios_base::floatfield);    // fixed-point
    float tub = 10.0 / 3.0;    // good to about 6 places
    double mint = 10.0 / 3.0;    // good to about 15 places
    const float million = 1.0e6;

    cout << "tub = " << tub;
    cout << ", a million tubs = " << million * tub;
    cout << ",\nand ten million tubs = ";
    cout <<  * million * tub << endl;

    cout << "mint = " << mint << " and a million mints = ";
    cout << million * mint << endl;

    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    float a = 2.34E+22f;
    float b = a + 1.0f;

    cout << "a = " << a << endl;
    cout << "b - a = " << b - a << endl;

    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;
    float hats, heads;

    cout.setf(ios_base::fixed, ios_base::floatfield);
    cout << "Enter a number: ";
    cin >> hats;
    cout << "Enter another number: ";
    cin >> heads;

    cout << "hats = " << hats << "; heads = " << heads << endl;
    cout << "hats + heads = " << hats + heads << endl;
    cout << "hats - heads = " << hats - heads << endl;
    cout << "hats * heads = " << hats * heads << endl;
    cout << "hats / heads = " << hats / heads << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    cout.setf(ios_base::fixed, ios_base::floatfield);
    cout <<  /  << endl;
    cout << "Floating-point division: 9.0 / 5.0 = ";
    cout << 9.0 / 5.0 << endl;
    cout <<  << endl;
    cout << "double constants: 1e7/9.0 = ";
    cout << .e7 / 9.0 << endl;
    cout << "float constants: 1e7f/ 9.0f = ";
    cout << .e7f / 9.0f << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    ;
    int lbs;

    cout << "Enter your weight in pounds: ";
    cin >> lbs;
    int stone = lbs / Lbs_per_stn;
    int pounds = lbs % Lbs_per_stn;
    cout << lbs << " pound are " << stone
        << " stone, " << pounds << " pound(s).\n";

    cin.get();
    cin.get();
    ;
}

#include <iostream>

int main() {
    using namespace std;

    cout.setf(ios_base::fixed, ios_base::floatfield);
    ;    // int converted to float
    int guess(3.9832);    // double converted to int
    int debt = 7.2E12;    // result not defined in C++
    cout << "tree = " << tree << endl;
    cout << "guess = " << guess << endl;
    cout << "debt = " << debt << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;
    int auks, bats, coots;

    // the following statement adds the values as double,
    // then converts the result to int
    auks = 19.99 + 11.99;

    // these statements add values as int
    bats = (int)19.99 + (int)11.99;    // old C syntax
    coots = int(19.99) + int(11.99);    // new C++ syntax;
    cout << "auks = " << auks << ", bats = " << bats;
    cout << ", coots = " << coots << endl;

    char ch = 'Z';
    cout << "The code for " << ch << " is ";    // print as char
    cout << int(ch) << endl;    // print as int
    cout << "Yes, the code is ";
    cout << static_cast<int>(ch) << endl;    // using static_cast

    cin.get();
    ;

}

#include <iostream>

int main() {
    using namespace std;
    ];
    yams[] = ;
    yams[] = ;
    yams[] = ;

    ] = { ,, };

    cout << "Total yams = ";
    cout << yams[] + yams[] + yams[] << endl;

    cout << ] << " yams costs ";
    cout << yamcosts[] << " cents per yam.\n";

    ] * yamcosts[] + yams[] * yamcosts[];
    total = total + yams[] * yamcosts[];
    cout << "The total yam expense is " << total << " cents.\n";

    cout << "\nSize of yams array = " << sizeof yams;
    cout << " bytes.\n";
    cout << ];
    cout << " bytes.\n";

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <cstring>

int main() {
    using namespace std;

    ;
    char name1[Size];
    char name2[Size] = "C++owboy";

    cout << "Howdy! I'm " << name2;
    cout << "! What's your name?\n";
    cin >> name1;
    cout << "Well, " << name1 << ", your name has ";
    cout << strlen(name1) << " letters and is stored\n";
    cout << "in an array of " << sizeof(name1) << " bytes.\n";
    cout << ] << ".\n";
    name2[] = '\0';
    cout << "Here are the first 3 characters of my name: ";
    cout << name2 << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    ;
    char name[ArSize];
    char dessert[ArSize];

    cout << "Enter your name:\n";
    cin >> name;
    cout << "Enter your favorite dessert:\n";
    cin >> dessert;
    cout << "I have some delicious " << dessert;
    cout << " for you, " << name << ".\n";

    cin.get();
    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    ;
    char name[ArSize];
    char dessert[ArSize];

    cout << "Enter your name:\n";
    cin.getline(name, ArSize);
    cout << "Enter your favorite dessert:\n";
    cin.getline(dessert, ArSize);
    cout << "I have some delicious " << dessert;
    cout << " for you, " << name << ".\n";

    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    ;
    char name[ArSize];
    char dessert[ArSize];

    cout << "Enter your name:\n";
    cin.get(name, ArSize).get();
    cout << "Enter your favorite dessert:\n";
    cin.get(dessert, ArSize).get();
    cout << "I have some delicious " << dessert;
    cout << " for you, " << name << ".\n";

    cin.get();

    ;
}

#include <iostream>
#include <string>

int main() {
    using namespace std;

    ];
    ] = "jaguar";
    string str1;
    string str2 = "panther";

    cout << "Enter a kind of feline: ";
    cin >> charr1;
    cout << "Enter another kind of feline: ";
    cin >> str1;
    cout << "Here are some felines:\n";
    cout << charr1 << " " << charr2 << " "
        << str1 << " " << str2
        << endl;
    cout << "The thrid letter in " << charr2 << " is "
        << charr2[] << endl;
    cout << "The third letter in " << str2 << " is "
        << str2[] << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <string>

int main() {
    using namespace std;

    string s1 = "penguin";
    string s2, s3;

    cout << "You can assign one string object to another: s2 = s1\n";
    s2 = s1;
    cout << "s1: " << s1 << ", s2: " << s2 << endl;
    cout << "You can assign a C-style string to a string object.\n";
    cout << "s2 = \"buzzard\"\n";
    s2 = "buzzard";
    cout << "s2: " << s2 << endl;
    cout << "You can concatenate strings: s3 = s1 + s2\n";
    s3 = s1 + s2;
    cout << "s3: " << s3 << endl;
    cout << "You can append strings.\n";
    s1 += s2;
    cout << "s1 += s2 yields s1 = " << s1 << endl;
    s2 += " for a day";
    cout << "s2 += \" for a day\" yields s2 = " << s2 << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <string>
#include <cstring>

int main() {
    using namespace std;

    ];
    ] = "jaguar";
    string str1;
    string str2 = "panther";

    str1 = str2;
    strcpy_s(charr1, charr2);

    str1 += " paste";
    strcat_s(charr1, " juice");

    int len1 = str1.size();
    int len2 = strlen(charr1);

    cout << "The string " << str1 << " contains "
        << len1 << " characters.\n";
    cout << "The string " << charr1 << " contains "
        << len2 << " characters.\n";

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <string>
#include <cstring>

int main() {
    using namespace std;

    ];
    string str;

    cout << "Length of string in charr before input: "
        << strlen(charr) << endl;
    cout << "Length of string in str before input: "
        << str.size() << endl;
    cout << "Enter a line of text:\n";
    cin.getline(charr, );
    cout << "You entered: " << charr << endl;
    cout << "Enter another line of text:\n";
    getline(cin, str);
    cout << "You entered: " << str << endl;
    cout << "Length of string in charr after input: "
        << strlen(charr) << endl;
    cout << "Lenth of string in str after input: "
        << str.size() << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>

struct inflatable {
    ];
    float volume;
    double price;
};

int main() {
    using namespace std;

    struct inflatable guest = {
        "Glorious Gloria",
        1.88,
        29.99
    };

    inflatable pal = {
        "Audacious Arthur",
        3.12,
        32.99
    };

    cout << "Expand your guest list with " << guest.name;
    cout << " and " << pal.name << "!\n";
    cout << "You can have both for $";
    cout << guest.price + pal.price << "!\n";

    cin.get();
    cin.get();

    ;
}

#include <iostream>

struct inflatable {
    ];
    float volume;
    double price;
};

int main() {
    using namespace std;

    inflatable bouquet = {
        "sunflowers",
        0.20,
        12.49
    };
    inflatable choice;

    cout << "bouquet: " << bouquet.name << " for $";
    cout << bouquet.price << endl;

    choice = bouquet;
    cout << "choice: " << choice.name << " for $";
    cout << choice.price << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>

struct inflatable {
    ];
    float volume;
    double price;
};

int main() {
    using namespace std;

    inflatable guests[] = {
        { "Bambi", 0.5, 21.99 },
        { , 565.99 }
    };

    cout << ].name << ].name
        << "\nhave a combined volume of "
        << guests[].volume + guests[].volume << " cubic feet.\n";

    cin.get();
    cin.get();

    ;
}

struct torgle_register {
    unsigned ;
    unsigned ;
    ;
    ;
};

#include <iostream>

int main() {
    using namespace std;
    ;
    double cups = 4.5;

    cout << "donuts value = " << donuts;
    cout << " and donuts address = " << &donuts << endl;

    cout << "cups value = " << cups;
    cout << " and cups address = " << &cups << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <string>

int main() {
    using namespace std;

    ;
    int *p_updates;
    p_updates = &updates;

    cout << "Values: updates = " << updates;
    cout << ", *p_updates = " << *p_updates << endl;

    cout << "Addresses: &updates = " << &updates;
    cout << ", p_updates = " << p_updates << endl;

    *p_updates = *p_updates + ;
    cout << "Now updates = " << updates << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <string>

int main() {
    using namespace std;

    ;
    int* pt = &higgens;
    cout << "Value of higgens = " << higgens
        << "; Address of higgens = " << &higgens << endl;
    cout << "Value of *pt = " << *pt
        << "; Value of pt = " << pt << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    ;
    int * pt = new int;
    *pt = ;

    cout << "nights value = ";
    cout << nights << ": location " << &nights << endl;
    cout << "int ";
    cout << "value = " << *pt << ": location = " << pt << endl;

    double * pd = new double;
    *pd = 10000001.0;

    cout << "double ";
    cout << "value = " << *pd << ": location = " << pd << endl;
    cout << "location of pointer pd: " << &pd << endl;

    cout << "size of pt = " << sizeof(pt);
    cout << ": size of *pt = " << sizeof(*pt) << endl;
    cout << "size of pd = " << sizeof pd;
    cout << ": size of *pd = " << sizeof(*pd) << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    ];
    p3[] = 0.2;
    p3[] = 0.5;
    p3[] = 0.8;
    cout << ] << ".\n";
    p3 = p3 + ;
    cout << ] << " and ";
    cout << ] << ".\n";
    p3 = p3 - ;
    delete[] p3;

    cin.get();
    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    ] = { 100000.0, 20000.0, 30000.0 };
    ] = { , ,  };

    // here are two ways to get the address of an array
    double * pw = wages;    // name of an array = address
    ];    // name of an array = address

    cout << "pw = " << pw << ", *pw = " << *pw << endl;
    pw = pw + ;
    cout << "add 1 to the pw pointer:\n";
    cout << "pw = " << pw << ", *pw = " << *pw << "\n\n";

    cout << "ps = " << ps << ", *ps = " << *ps << endl;
    ps = ps + ;
    cout << "add 1 to the ps pointer:\n";
    cout << "ps = " << ps << ", *ps = " << *ps << "\n\n";

    cout << "access two elements with array notation\n";
    cout << ]
        << ] << endl;
    cout << "access two elements with pointer notation\n";
    cout << "*stacks = " << *stacks
        << ) << endl;

    cout << sizeof(wages) << " = size of wages array\n";
    cout << sizeof(pw) << " = size of pw pointer\n";

    cin.get();
    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    ];
    cout << tell <<  << endl;    // displays &tell[0]

    ] = &tell;
    cout << pas <<  << endl;    // displays address of whole array

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>

int main() {
    using namespace std;

    ] = "bear";
    const char * bird = "wren";
    char * ps;

    cout << animal << " and ";
    cout << bird << "\n";

    cout << "Enter a kind of animal: ";
    cin >> animal;

    ps = animal;
    cout << ps << "!\n";
    cout << "Before using strcpy():\n";
    cout << animal << " at " << (int *)animal << endl;
    cout << ps << " at " << (int *)ps << endl;

    ps = ];
    strcpy(ps, animal);
    cout << "After using strcpy():\n";
    cout << animal << " at " << (int *)animal << endl;
    cout << ps << " at " << (int *)ps << endl;

    delete[] ps;

    cin.get();
    cin.get();

    ;
}

#include <iostream>

struct inflatable {
    ];
    float volume;
    double price;
};

int main() {
    using namespace std;

    inflatable * ps = new inflatable;

    cout << "Enter name of inflatable item: ";
    cin.);

    cout << "Enter volume in cubic feet: ";
    cin >> (*ps).volume;

    cout << "Enter price: $";
    cin >> ps->price;

    cout << "Name: " << (*ps).name << endl;
    cout << "Volume: " << ps->volume << " cubic feet\n";
    cout << "Price: $" << ps->price << endl;

    delete ps;

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <cstring>

using namespace std;

char * getname(void);

int main() {
    char * name;

    name = getname();
    cout << name << " at " << (int *)name << endl;
    delete[] name;

    name = getname();
    cout << name << " at " << (int *)name << "\n";
    delete[] name;

    cin.get();
    cin.get();

    ;
}

char * getname() {
    ];
    cout << "Enter last name: ";
    cin >> temp;
    ];
    strcpy(pn, temp);

    return pn;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <cstring>

using namespace std;

struct antarctica_years_end {
    int year;
};

int main() {
    antarctica_years_end s01, s02, s03;
    s01.year = ;
    antarctica_years_end * pa = &s02;
    pa->year = ;
    antarctica_years_end trio[];
    trio[].year = ;
    std::cout << trio->year << std::endl;
    ] = { &s01, &s02, &s03 };
    std::cout << arp[]->year << std::endl;
    const antarctica_years_end ** ppa = arp;
    auto ppb = arp;
    std::cout << (*ppa)->year << std::endl;
    std::cout << (*(ppb + ))->year << std::endl;

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <vector> // STL C++98
#include <array> // C++ 11

int main() {
    using namespace std;
    // C,original C++
    ] = { 1.2, 2.4, 3.6, 4.8 };

    // C++98 STL
    vector<);    // create vector with 4 elements
    // no simple way to initialize in C98
    a2[] = 1.0 / 3.0;
    a2[] = 1.0 / 5.0;
    a2[] = 1.0 / 7.0;
    a2[] = 1.0 / 9.0;

    // C++11 -- create and initialize array object
    array<> a3 = { 3.14, 2.72, 1.62, 1.41 };
    array<> a4;

    a4 = a3;    // valid for array objects
    cout << ] << ] << endl;
    cout << ] << ] << endl;
    cout << ] << ] << endl;
    cout << ] << ] << endl;

    a1[-] = 20.2;
    cout << ] << ] << endl;
    cout << ] << ] << endl;
    cout << ] << ] << endl;

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

int main() {
    using namespace std;
    int i;
    ; i < ; i++) {
        cout << "C++ knows loops.\n";
    }
    cout << "C++ knows when to stop.\n";

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

int main() {
    using namespace std;
    cout << "Enter the string countdown value: ";
    int limit;
    cin >> limit;
    int i;
    for (i = limit; i; i--) {
        cout << "i = " << i << "\n";
    }
    cout << "Done now that i = " << i << "\n";

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

int main() {
    using namespace std;

    int x;
    cout << "The expression x = 100 has the value ";
    cout << (x = ) << endl;
    cout << "Now x = " << x << endl;
    cout << "The expression x < 3 has the value ";
    cout << (x < ) << endl;
    cout << "The expression x > 3 has the value ";
    cout << (x > ) << endl;
    cout.setf(ios_base::boolalpha);
    cout << "The expression x < 3 has the value ";
    cout << (x < ) << endl;
    cout << "The expression x > 3 has the value ";
    cout << (x > ) << endl;

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

;

int main() {
    using namespace std;

    long long factorials[ArSize];
    factorials[] = factorials[] = 1LL;
    ; i < ArSize; i++) {
        factorials[i] = i * factorials[i - ];
    }
    ; i < ArSize; i++) {
        std::cout << i << "! = " << factorials[i] << std::endl;
    }

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

;

int main() {
    using std::cout;
    using std::cin;
    using std::endl;

    cout << "Enter an integer: ";
    int by;
    cin >> by;
    cout << "Counting by " << by << "s:\n";
    ; i < ; i = i + by) {
        cout << i << endl;
    }

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>

int main() {
    using namespace std;

    cout << "Enter a word: ";
    string word;
    cin >> word;

    ; i >= ; i--) {
        cout << word[i];
    }

    cout << "\nBye.\n";

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>

int main() {
    using std::cout;
    using std::cin;

    ;
    ;
    cout << "a = " << a << ": b = " << b << "\n";
    cout << "a++ = " << a++ << ": ++b = " << ++b << "\n";
    cout << "a = " << a << ": b = " << b << "\n";

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <cstring>

int main() {
    using namespace std;

    ] = "?ate";
    for (char ch = 'a'; strcmp(word, "mate"); ch++) {
        cout << word << endl;
        word[] = ch;
    }

    cout << "After loop ends, word is " << word << endl;

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>

int main() {
    using namespace std;

    string word = "?ate";
    for (char ch = 'a'; word != "mate"; ch++) {
        cout << word << endl;
        word[] = ch;
    }

    cout << "After loop ends, word is " << word << endl;

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

;

int main() {
    using namespace std;

    char name[ArSize];
    cout << "Your first name, please: ";
    cin >> name;
    cout << "Here is your name, verticalized and ASCIIized:\n";
    ;
    while (name[i] != '\0') {
        cout << name[i] << ": " << int(name[i]) << endl;
        i++;
    }

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <ctime>

int main() {
    using namespace std;

    cout << "Enter the delay time, in seconds: ";
    float secs;
    cin >> secs;
    clock_t delay = secs * CLOCKS_PER_SEC;
    cout << "starting\a\n";
    clock_t start = clock();
    while (clock() - start < delay) {
        ;
    }

    cout << "done \a\n";

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

int main() {
    using namespace std;

    int n;

    cout << "Enter numbers in the range 1-10 to find ";
    cout << "my favorite number\n";
    do {
        cin >> n;
    } );

    cout << "Yes, 7 is my favorite.\n";

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

int main() {
    using namespace std;

    char ch;
    ;
    cout << "Enter characters; enter # to quit:\n";
    cin >> ch;
    while (ch != '#') {
        cout << ch << endl;
        ++count;
        cin >> ch;
    }

    cout << endl << count << " characters read\n";

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

int main() {
    using namespace std;

    char ch;
    ;

    cout << "Enter characters; enter # to quit:\n";
    cin.get(ch);
    while (ch != '#') {
        cout << ch;
        ++count;
        cin.get(ch);
    }

    cout << endl << count << " characters read\n";

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

int main() {
    using namespace std;

    char ch;
    ;
    cin.get(ch);
    while (cin.fail() == false) {
        cout << ch;
        ++count;
        cin.get(ch);
    }

    cout << endl << count << " characters read\n";

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

;
;

int main() {
    using namespace std;

    const char * cities[Cities] = {
        "Gribble City",
        "Gribbletown",
        "New Gribble",
        "San Gribble",
        "Gribble Vista"
    };

    int maxtemps[Years][Cities] = {
        { , , , ,  },
        { , , , ,  },
        { , , , ,  },
        { , , , ,  }
    };

    cout << "Maximum temperatures for 2008 - 2011\n\n";
    ; city < Cities; ++city) {
        cout << cities[city] << ":\t";
        ; year < Years; ++year) {
            cout << maxtemps[year][city] << "\t";
        }
        cout << endl;
    }

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

;
;

int main() {
    using std::cin;
    using std::cout;

    char ch;
    ;
    ;
    cin.get(ch);

    while (ch != '.') {
        if (ch == ' ') {
            ++spaces;
        }
        ++total;
        cin.get(ch);
    }

    cout << spaces << " spaces, " << total;
    cout << " characters total in sentence\n";

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <cctype>

int main() {
    using namespace std;

    cout << "Enter text for analysis, and type @"
        " to terminate input.\n";
    char ch;
    ;
    ;
    ;
    ;
    ;

    cin.get(ch);
    while (ch != '@') {
        if (isalpha(ch))
            chars++;
        else if (isspace(ch))
            whitespace++;
        else if (isdigit(ch))
            digits++;
        else if (ispunct(ch))
            punct++;
        else
            others++;
        cin.get(ch);
    }

    cout << chars << " letters, "
        << whitespace << " whitespace, "
        << digits << " digits, "
        << punct << " punctuations, "
        << others << " others.\n";

    std::cin.get();
    std::cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <fstream>

int main() {
    using namespace std;

    ];
    int year;
    double a_price;
    double d_price;

    ofstream outFile;
    outFile.open("carinfo.txt");

    cout << "Enter the make and model of automobile: ";
    cin.getline(automobile, );

    cout << "Enter the model year: ";
    cin >> year;

    cout << "Enter the original asking price: ";
    cin >> a_price;
    d_price = 0.913 * a_price;

    cout << fixed;
    cout.precision();
    cout.setf(ios_base::showpoint);
    cout << "Make and model: " << automobile << endl;
    cout << "Year: " << year << endl;
    cout << "Was asking $" << a_price << endl;
    cout << "Now asking $" << d_price << endl;

    outFile << fixed;
    outFile.precision();
    outFile.setf(ios_base::showpoint);
    outFile << "Make and model: " << automobile << endl;
    outFile << "Year: " << year << endl;
    outFile << "Was asking $" << a_price << endl;
    outFile << "Now asking $" << d_price << endl;

    outFile.close();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <fstream>
#include <cstdlib> // support for exit()

;

int main() {
    using namespace std;

    char filename[SIZE];

    ifstream inFile;
    cout << "Enter name of data file: ";
    cin.getline(filename, SIZE);
    inFile.open(filename);
    if (!inFile.is_open()) {
        cout << "Could not open the file " << filename << endl;
        cout << "Program terminating.\n";
        exit(EXIT_FAILURE);
    }

    double value;
    double sum = 0.0;
    ;

    inFile >> value;
    while (inFile.good()) {
        ++count;
        sum += value;
        inFile >> value;
    }

    if (inFile.eof()) {
        cout << "End of file reached.\n";
    } else if (inFile.fail()) {
        cout << "Input terminated by data mismatch.\n";
    } else {
        cout << "Input terminated for unknown reason.\n";
    }

    ) {
        cout << "No data processed.\n";
    } else {
        cout << "Items read: " << count << endl;
        cout << "Sum: " << sum << endl;
        cout << "Average: " << sum / count << endl;
    }

    inFile.close();

    cin.get();
    cin.get();

    ;
}

#include <iostream>

using namespace std;

void n_chars(char, int);

int main() {

    int times;
    char ch;

    cout << "Enter a characters: ";
    cin >> ch;

    while (ch != 'q') {
        cout << "Enter an integer: ";
        cin >> times;
        n_chars(ch, times);
        cout << "\nEnter another character or press the"
            << " q-key to quit: ";
        cin >> ch;
    }

    cout << "The value of times is " << times << ".\n";
    cout << "Bye\n";

    cin.get();
    cin.get();

    ;
}

void n_chars(char c, int n) {
    ) {
        cout << c;
    }
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

;

int sum_arr(int arr[], int n);

int main() {
    , , , , , , ,  };

    std::cout << cookies << " = array address, ";
    std::cout << sizeof cookies << " = sizeof cookies\n";

    int sum = sum_arr(cookies, ArSize);
    std::cout << "Total cookies eaten: " << sum << std::endl;

    sum = sum_arr(cookies, );
    std::cout << "First three eaters ate " << sum << " cookies.\n";

    sum = sum_arr(cookies + , );
    std::cout << "Last four eaters ate " << sum << " cookies.\n";

    std::cin.get();
    std::cin.get();

    ;
}

int sum_arr(int arr[], int n) {
    ;
    std::cout << arr << " = arr, ";
    std::cout << sizeof arr << " = sizeof arr\n";
    ; i < n; i++) {
        total = total + arr[i];
    }
    return total;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

;

int sum_arr(const int * begin, const int * end);

int main() {
    using namespace std;

    , , , , , , ,  };

    int sum = sum_arr(cookies, cookies + ArSize);
    cout << "Total cookies eaten: " << sum << endl;
    sum = sum_arr(cookies, cookies + );
    cout << "First three eaters ate " << sum << " cookies.\n";
    sum = sum_arr(cookies + , cookies + );
    cout << "Last four eaters ate " << sum << " cookies.\n";

    std::cin.get();
    std::cin.get();

    ;
}

int sum_arr(const int * begin, const int * end) {
    const int * pt;
    ;

    for (pt = begin; pt != end; pt++) {
        total = total + *pt;
    }

    return total;
}

#include <iostream>

char * buildstr(char c, int n);

int main() {
    using namespace std;

    int times;
    char ch;

    cout << "Enter a character: ";
    cin >> ch;
    cout << "Enter an integer: ";
    cin >> times;
    char * ps = buildstr(ch, times);
    cout << ps << endl;
    delete[] ps;
    ps = buildstr();
    cout << ps << "-DONE-" << ps << endl;
    delete[] ps;

    cin.get();
    cin.get();

    ;
}

char * buildstr(char c, int n) {
    ];
    pstr[n] = '\0';
    ) {
        pstr[n] = c;
    }
    return pstr;
}

#include <iostream>

struct travel_time {
    int hours;
    int mins;
};

;

travel_time sum(travel_time t1, travel_time t2);
void show_time(travel_time t);

int main() {
    using namespace std;

    travel_time day1 = { ,  };
    travel_time day2 = { ,  };

    travel_time trip = sum(day1, day2);
    cout << "Two-day total: ";
    show_time(trip);

    travel_time day3 = { ,  };
    cout << "Three-day total: ";
    show_time(sum(trip, day3));

    cin.get();
    cin.get();

    ;
}

travel_time sum(travel_time t1, travel_time t2) {
    travel_time total;

    total.mins = (t1.mins + t2.mins) % Mins_per_hr;
    total.hours = t1.hours + t2.hours + (t1.mins + t2.mins) / Mins_per_hr;

    return total;
}

void show_time(travel_time t) {
    using namespace std;
    cout << t.hours << " hours, "
        << t.mins << " minutes\n";
}

#include <iostream>
#include <cmath>

struct polar {
    double distance;
    double angle;
};

struct rect {
    double x;
    double y;
};

polar rect_to_polar(rect xypos);
void show_polar(polar dapos);

int main() {
    using namespace std;

    rect rplace;
    polar pplace;

    cout << "Enter the x and y values: ";
    while (cin >> rplace.x >> rplace.y) {
        pplace = rect_to_polar(rplace);
        show_polar(pplace);
        cout << "Next two numbers (q to quit): ";
    }
    cout << "Done.\n";

    cin.get();
    cin.get();

    ;
}

polar rect_to_polar(rect xypos) {
    using namespace std;
    polar answer;

    answer.distance = sqrt(xypos.x * xypos.x + xypos.y * xypos.y);
    answer.angle = atan2(xypos.y, xypos.x);
    return answer;
}

void show_polar(polar dapos) {
    using namespace std;
    const double Rad_to_deg = 57.29577951;

    cout << "distance = " << dapos.distance;
    cout << ", angle = " << dapos.angle * Rad_to_deg;
    cout << " degrees\n";
}

#include <iostream>
#include <string>

using namespace std;
;
void display(const string sa[], int n);

int main() {
    string list[SIZE];
    cout << "Enter your " << SIZE << " favorite astronomical sights:\n";

    ; i < SIZE; i++) {
        cout << i +  << ": ";
        getline(cin, list[i]);
    }

    cout << "Your list:\n";
    display(list, SIZE);

    cin.get();
    cin.get();

    ;
}

void display(const string sa[], int n) {
    ; i < n; i++) {
        cout << i +  << ": " << sa[i] << endl;
    }
}

#include <iostream>
#include <array>
#include <string>

;
const std::array<std::string, Seasons> Snames = { "Spring", "Summer", "Fall", "Winter" };

void fill(std::array<double, Seasons> * pa);
void show(std::array<double, Seasons> da);

int main() {
    std::array<double, Seasons> expenses;
    fill(&expenses);
    show(expenses);

    std::cin.get();
    std::cin.get();

    ;
}

void fill(std::array<double, Seasons> * pa) {
    using namespace std;
    ; i < Seasons; i++) {
        cout << "Enter " << Snames[i] << " expenses: ";
        cin >> (*pa)[i];
    }
}

void show(std::array<double, Seasons> da) {
    using namespace std;

    double total = 0.0;
    cout << "\nEXPENSES\n";
    ; i < Seasons; i++) {
        cout << Snames[i] << ": $" << da[i] << endl;
        total += da[i];
    }
    cout << "Total Expenses: $" << total << endl;
}

#include <iostream>

double betsy(int);
double pam(int);

void estimate(int lines, double(*pf)(int));

int main() {
    using namespace std;

    int code;
    cout << "How many lines of code do you need? ";
    cin >> code;
    cout << "Here's Betsy's estimate:\n";
    estimate(code, betsy);
    cout << "Here's Pam's estimate:\n";
    estimate(code, pam);

    cin.get();
    cin.get();

    ;
}

double betsy(int lns) {
    return 0.5 * lns;
}

double pam(int lns) {
    return 0.3 * lns + 0.00004 * lns * lns;
}

void estimate(int lines, double(*pf)(int)) {
    using namespace std;
    cout << lines << " lines will take ";
    cout << (*pf)(lines) << " hour(s)\n";
}

#include <iostream>

const double * f1(const double arr[], int n);
const double * f2(const double[], int);
const double * f3(const double *, int);

int main() {
    using namespace std;

    ] = { 1112.3, 1542.6, 2227.9 };

    const double *(*p1)(const double *, int) = f1;
    auto p2 = f2;
    cout << "Using pointers to functions:\n";
    cout << " Address Value\n";
    cout << (*p1)(av, ) << ) << endl;
    cout << p2(av, ) << ) << endl;

    ])(const double *, int) = { f1, f2, f3 };
    auto pb = pa;
    cout << "\nUsing an array of pointers to functions:\n";
    cout << " Address Value\n";
    ; i < ; i++) {
        cout << pa[i](av, ) << ) << endl;
    }
    cout << "\nUsing a pointer to a pointer to a function:\n";
    cout << " Address Value\n";
    ; i < ; i++) {
        cout << pb[i](av, ) << ) << endl;
    }

    cout << "\nUsing pointers to an array of pointers:\n";
    cout << " Address Value\n";
    auto pc = &pa;
    cout << (*pc)[](av, ) << ](av, ) << endl;
    ])(const double *, int) = &pa;
    ](av, );
    cout << pdb << ": " << *pdb << endl;
    cout << (*(*pd)[])(av, ) << ])(av, ) << endl;

    cin.get();
    cin.get();

    ;
}

const double * f1(const double * ar, int n) {
    return ar;
}

const double * f2(const double ar[], int n) {
    ;
}

const double * f3(const double ar[], int n) {
    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

inline double square(double x) {
    return x * x;
}

int main() {
    using namespace std;

    double a, b;
    double c = 13.0;

    a = square(5.0);
    b = square(4.5 + 7.5);

    cout << "a = " << a << ", b = " << b << "\n";
    cout << "c = " << c;
    cout << ", c squared = " << square(c++) << "\n";
    cout << "Now c = " << c << "\n";

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

int main() {
    using namespace std;

    ;
    int & rodents = rats;
    cout << "rats = " << rats;
    cout << ", rodents = " << rodents << endl;
    rodents++;
    cout << "rats = " << rats;
    cout << ", rodents = " << rodents << endl;

    cout << "rats address = " << &rats;
    cout << ", rodents address = " << &rodents << endl;

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

int main() {
    using namespace std;

    ;
    int & rodents = rats;

    cout << "rats = " << rats;
    cout << ", rodents = " << rodents << endl;

    cout << "rats address = " << &rats;
    cout << ", rodents address = " << &rodents << endl;

    ;
    rodents = bunnies;

    cout << "bunnies = " << bunnies;
    cout << ", rats = " << rats;
    cout << ", rodents = " << rodents << endl;

    cout << "bunnies address = " << &bunnies;
    cout << ", rodents address = " << &rodents << endl;

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

void swapr(int & a, int & b);
void swapp(int * p, int * q);
void swapv(int a, int b);

int main() {
    using namespace std;

    ;
    ;

    cout << "wallet1 = $" << wallet1;
    cout << " wallet2 = $" << wallet2 << endl;

    cout << "Using references to swap contents:\n";
    swapr(wallet1, wallet2);
    cout << "wallet1 = $" << wallet1;
    cout << " wallet2 = $" << wallet2 << endl;

    cout << "Using pointers to swap contents again:\n";
    swapp(&wallet1, &wallet2);
    cout << "wallet1 = $" << wallet1;
    cout << " wallet2 = $" << wallet2 << endl;

    cout << "Trying to use passing by value.\n";
    swapv(wallet1, wallet2);
    cout << "wallet1 = $" << wallet1;
    cout << " wallet2 = $" << wallet2 << endl;

    cin.get();
    cin.get();

    ;
}

void swapr(int & a, int & b) {
    int temp;
    temp = a;
    a = b;
    b = temp;
}

void swapp(int * p, int * q) {
    int temp;
    temp = *p;
    *p = *q;
    *q = temp;
}

void swapv(int a, int b) {
    int temp;
    temp = a;
    a = b;
    b = temp;
}

#include <iostream>

double cube(double a);
double refcube(double & ra);

int main() {
    using namespace std;

    double x = 3.0;

    cout << cube(x);
    cout << " = cube of " << x << endl;
    cout << refcube(x);
    cout << " = cube of " << x << endl;

    cin.get();
    cin.get();

    ;
}

double cube(double a) {
    a *= a * a;
    return a;
}

double refcube(double &ra) {
    ra *= ra * ra;
    return ra;
}

#include <iostream>
#include <string>

struct free_throws {
    std::string name;
    int made;
    int attempts;
    float percent;
};

void display(const free_throws & ft);
void set_pc(free_throws & ft);
free_throws & accumulate(free_throws & target, const free_throws & source);

int main() {
    using namespace std;

    free_throws one = { ,  };
    free_throws two = { ,  };
    free_throws three = {  ,  };
    free_throws four = { ,  };
    free_throws five = { ,  };
    free_throws team = {  ,  };

    free_throws dup;

    set_pc(one);
    display(one);

    accumulate(team, one);
    display(team);

    display(accumulate(team, two));
    accumulate(accumulate(team, three), four);
    display(team);

    dup = accumulate(team, five);
    std::cout << "Displaying team:\n";
    display(team);
    std::cout << "Displaying dup after assignment:\n";
    display(dup);
    set_pc(four);

    accumulate(dup, five) = four;
    std::cout << "Displaying dup after ill-advised assignment:\n";
    display(dup);

    cin.get();
    cin.get();

    ;
}

void display(const free_throws & ft) {
    using std::cout;
    cout << "Name: " << ft.name << '\n';
    cout << " Made: " << ft.made << '\t';
    cout << "Attempts: " << ft.attempts << '\t';
    cout << "Percent: " << ft.percent << '\n';
}

void set_pc(free_throws & ft) {
    ) {
        ft.percent = 100.0f * float(ft.made) / float(ft.attempts);
    } else {
        ft.percent = ;
    }
}

free_throws & accumulate(free_throws & target, const free_throws & source) {
    target.attempts += source.attempts;
    target.made += source.made;
    set_pc(target);
    return target;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>

using namespace std;

string version1(const string & s1, const string & s2);
const string & version2(string & s1, const string & s2);
const string & version3(string & s1, const string & s2);

int main() {
    string input;
    string copy;
    string result;

    cout << "Enter a string: ";
    getline(cin, input);
    copy = input;

    cout << "Your string as entered: " << input << endl;

    result = version1(input, "***");
    cout << "Your string enhanced: " << result << endl;
    cout << "Your original string: " << input << endl;

    result = version2(input, "###");
    cout << "Your string enhanced: " << result << endl;
    cout << "Your original string: " << input << endl;

    cout << "Resetting original string.\n";
    input = copy;
    result = version3(input, "@@@");
    cout << "Your string enhanced: " << result << endl;
    cout << "Your original string: " << input << endl;

    cin.get();
    cin.get();

    ;
}

string version1(const string & s1, const string & s2) {
    string temp;
    temp = s2 + s1 + s2;
    return temp;
}

const string & version2(string & s1, const string & s2) {
    s1 = s2 + s1 + s2;
    return s1;
}

const string & version3(string & s1, const string & s2) {
    string temp;

    temp = s2 + s1 + s2;
    return temp;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <fstream>
#include <cstdlib>
using namespace std;

void file_it(ostream & os, double fo, const double fe[], int n);
;

int main() {
    ofstream fout;
    const char * fn = "ep-data.txt";
    fout.open(fn);
    if (!fout.is_open()) {
        cout << "Can't open " << fn << ". Bye.\n";
        exit(EXIT_FAILURE);
    }
    double objective;
    cout << "Enter the focal length of your "
        << "telescope objective in mm: ";
    cin >> objective;
    double eps[LIMIT];
    cout << "Enter the focal lengths, in mm, of " << LIMIT
        << " eyepieces:\n";
    ; i < LIMIT; i++) {
        cout <<  << ": ";
        cin >> eps[i];
    }
    file_it(fout, objective, eps, LIMIT);
    file_it(cout, objective, eps, LIMIT);
    cout << "Done\n";

    cin.get();
    cin.get();

    ;
}

void file_it(ostream & os, double fo, const double fe[], int n) {
    ios_base::fmtflags initial;
    initial = os.setf(ios_base::fixed);
    os.precision();
    os << "Focal length of objective: " << fo << "mm\n";
    os.setf(ios::showpoint);
    os.precision();
    os.width();
    os << "f.1. eyeprece";
    os.width();
    os << "magnification" << endl;
    ; i < n; i++) {
        os.width();
        os << fe[i];
        os.width();
        os << int(fo / fe[i] + 0.5) << endl;
    }
    os.setf(initial);
}

#include <iostream>

;
);

int main() {
    using namespace std;

    char sample[ArSize];
    cout << "Enter a string:\n";
    cin.get(sample, ArSize);
    );
    cout << ps << endl;
    delete[] ps;
    ps = left(sample);
    cout << ps << endl;
    delete[] ps;

    cin.get();
    cin.get();

    ;
}

char * left(const char * str, int n) {
    ) {
        n = ;
    }

    ];

    int i;
    ; i < n && str[i]; i++) {
        p[i] = str[i];
    }
    while (i <= n) {
        p[i++] = '\0';
    }

    return p;
}

#include <iostream>

unsigned long left(unsigned long num, unsigned ct);
);

int main() {
    using namespace std;

    const char * trip = "Hawaii!!";
    unsigned ;
    int i;
    char * temp;

    ; i < ; i++) {
        cout << left(n, i) << endl;
        temp = left(trip, i);
        cout << temp << endl;
        delete[] temp;
    }

    cin.get();
    cin.get();

    ;
}

unsigned long left(unsigned long num, unsigned ct) {
    unsigned digits = ;
    unsigned long n = num;

     || num == ) {
        ;
    }

    ) {
        digits++;
    }

    if (digits > ct) {
        ct = digits - ct;
        while (ct--) {
            num /= ;
        }
        return num;
    } else {
        return num;
    }

}

char * left(const char * str, int n) {
    ) {
        n = ;
    }
    ];
    int i;
    ; i < n && str[i]; i++) {
        p[i] = str[i];
    }
    while (i <= n) {
        p[i++] = '\0';
    }
    return p;
}

#include <iostream>

template <typename T> void Swap(T & a, T &b);

int main() {
    using namespace std;

    ;
    ;
    cout << "i, j = " << i << ", " << j << ".\n";
    cout << "Using compiler-generated int swapper:\n";
    Swap(i, j);
    cout << "Now i, j = " << i << ", " << j << ".\n";

    double x = 24.5;
    double y = 81.7;
    cout << "x, y = " << x << ", " << y << ".\n";
    Swap(x, y);
    cout << "Now x,y = " << x << ", " << y << ".\n";

    cin.get();
    cin.get();

    ;
}

template <typename T> void Swap(T & a, T & b) {
    T temp;
    temp = a;
    a = b;
    b = temp;
}

#include <iostream>

template <typename T> void Swap(T & a, T & b);
template <typename T> void Swap(T * a, T * b, int n);

void Show(int a[]);
;

int main() {
    using namespace std;

    , j = ;
    cout << "i, j = " << i << ", " << j << ".\n";
    cout << "Using compiler-generated int swapper:\n";
    Swap(i, j);
    cout << "Now i, j = " << i << ", " << j << ".\n";

    , , , , , , ,  };
    , , , , , , ,  };
    cout << "Original arrays:\n";
    Show(d1);
    Show(d2);
    Swap(d1, d2, Lim);
    cout << "Swapped arrays:\n";
    Show(d1);
    Show(d2);

    cin.get();
    cin.get();

    ;
}

template <typename T> void Swap(T & a, T & b) {
    T temp;
    temp = a;
    a = b;
    b = temp;
}

template <typename T> void Swap(T a[], T b[], int n) {
    T temp;
    ; i < n; i++) {
        temp = a[i];
        a[i] = b[i];
        b[i] = temp;
    }
}

void Show(int a[]) {
    using namespace std;
    cout << a[] << a[] << "/";
    cout << a[] << a[] << "/";
    ; i < Lim; i++) {
        cout << a[i];
    }
    cout << endl;
}

#include <iostream>

template <typename T> void Swap(T & a, T & b);

struct job {
    ];
    double salary;
    int floor;
};

template<> void Swap<job>(job & j1, job & j2);

void Show(job & j);

int main() {
    using namespace std;

    cout.precision();
    cout.setf(ios::fixed, ios::floatfield);
    , j = ;
    cout << "i, j= " << i << ", " << j << ".\n";
    cout << "Using compiler-generated int swapper:\n";
    Swap(i, j);
    cout << "Now i, j  = " << i << ", " << j << ".\n";

    job sue = {  };
    job sidney = {  };
    cout << "Before job swapping:\n";
    Show(sue);
    Show(sidney);
    Swap(sue, sidney);
    cout << "After job swapping:\n";
    Show(sue);
    Show(sidney);

    cin.get();
    cin.get();

    ;
}

template <typename T> void Swap(T & a, T & b) {
    T temp;
    temp = a;
    a = b;
    b = temp;
}

template<> void Swap<job>(job & j1, job & j2) {
    double t1;
    int t2;

    t1 = j1.salary;
    j1.salary = j2.salary;
    j2.salary = t1;
    t2 = j1.floor;
    j1.floor = j2.floor;
    j2.floor = t2;
}

void Show(job & j) {
    using namespace std;
    cout << j.name << ": $" << j.salary
        << " on floor " << j.floor << endl;
}

#ifndef COORDIN_H_
#define COORDIN_H_

struct polar {
    double distance;
    double angle;
};

struct rect {
    double x;
    double y;
};

polar rect_to_polar(rect xypos);
void show_polar(polar dapos);

#endif

#include <iostream>
#include "coordin.h"

using namespace std;

int main() {
    rect rplace;
    polar pplace;

    cout << "Enter the x and y values: ";
    while (cin >> rplace.x >> rplace.y) {
        pplace = rect_to_polar(rplace);
        show_polar(pplace);
        cout << "Next two numbers (q to quit): ";
    }
    cout << "Bye!\n";

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <cmath>
#include "coordin.h"

polar rect_to_polar(rect xypos) {
    using namespace std;
    polar answer;

    answer.distance = sqrt(xypos.x * xypos.x + xypos.y * xypos.y);
    answer.angle = atan2(xypos.y, xypos.x);
    return answer;
}

void show_polar(polar dapos) {
    using namespace std;

    const double Rad_to_deg = 57.29577951;

    cout << "distance = " << dapos.distance;
    cout << ", angle = " << dapos.angle * Rad_to_deg;
    cout << " degrees\n";
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

void oil(int x);

int main() {
    using namespace std;

    ;
    ;

    cout << "In main(), texas = " << texas << ", &texas = ";
    cout << &texas << endl;
    cout << "In main(), year = " << year << ", &year = ";
    cout << &year << endl;
    oil(texas);
    cout << "In main(), texas = " << texas << ", &texas = ";
    cout << &texas << endl;
    cout << "In main(), year = " << year << ", &year = ";
    cout << &year << endl;

    cin.get();
    cin.get();

    ;
}

void oil(int x) {
    using namespace std;
    ;

    cout << "In oil(), texas = " << texas << ", &texas = ";
    cout << &texas << endl;
    cout << "In oil(), x = " << x << ", &x = ";
    cout << &x << endl;

    {
        ;
        cout << "In block, texas = " << texas;
        cout << ", &texas = " << &texas << endl;
        cout << "In block, x = " << x << ", &x = ";
        cout << &x << endl;
    }

    cout << "Post-block texas = " << texas;
    cout << ", &texas = " << &texas << endl;
}

;    // static duration,external linkage
;    // static duration,internal linkage
int main() {

}
void funct1(int n) {
    ;    // static duration, on linkage
}

double up;    // definition, up is 0
extern int blem;    // blem defined elsewhere
extern char gr = 'z';    // definition because initialized

// file01.cpp
;    // definition because of initialization
;    // also a definition
int fleas;    // also a definition

// file02.cpp
extern int cats;    // not definition because they use
extern int dogs;    // extern and have no initialization

// file98.cpp
// use cats, dogs, and fleas from file01.cpp
extern int cats;
extern int dogs;
exterrn int fleas;

#include <iostream>

extern double warming;    // use warming from another file

void update(double dt);
void local();

using std::cout;
void update(double dt) {    // modifies global variable
    extern double warming;    // optional redeclaration
    warming += dt;

    cout << "Updating global warming to " << warming;
    cout << " degrees.\n";
}

void local() {
    double warming = 0.8;    // new variable hides external one

    cout << "Local warming = " << warming << " degrees.\n";
    // access global variable with the scope resolution operator
    cout << "But global warming = " << ::warming;
    cout << " degrees.\n";

}

#include <iostream>

using namespace std;

double warming = 0.3;

void update(double dt);
void local();

int main() {
    cout << "Global warming is " << warming << " degress.\n";
    update(0.1);    // call function to change warming
    cout << "Global warming is " << warming << " degrees.\n";
    local();    // call function with local warming
    cout << "Global warming is " << warming << " degrees.\n";

    cin.get();
    cin.get();

    ;
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

;
;
;

void remove_access();

int main() {
    using namespace std;

    cout << "main() reports the following addresses:\n";
    cout << &tom << " = &tom, " << &dick << " = &dick, ";
    cout << &harry << " = &harry\n";
    remove_access();

    cin.get();
    cin.get();

    ;
}

#include <iostream>

extern int tom;
;
;

void remote_access() {
    using namespace std;

    cout << "remote_access() reports the following addresses:\n";
    cout << &tom << " = &tom, " << &dick << " = &dick, ";
    cout << &harry << " = &harry\n";
}

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

;

void strcount(const char * str);

int main() {
    using namespace std;

    char input[ArSize];
    char next;

    cout << "Enter a line:\n";
    cin.get(input, ArSize);

    while (cin) {
        cin.get(next);
        while (next != '\n') {
            cin.get(next);
        }
        strcount(input);
        cout << "Enter next line (empty line to quit):\n";
        cin.get(input, ArSize);
    }

    cout << "Bye\n";

    cin.get();
    cin.get();

    ;
}

void strcount(const char * str) {
    using namespace std;
    ;
    ;

    cout << "\"" << str << "\" contains ";
    while (*str++) {
        count++;
    }
    total += count;
    cout << count << " characters\n";
    cout << total << " characters total\n";
}

);    // *pi set to 6
double * pd = new double(99.99);    // *pd set to 99.99
struct where {double x; double y; double z;}
where * one = new where{2.5,5.3,7.2};
] { ,,, };
double * pdo = new double { 99.99 };    // *pd set to 99.99
void * operator new(std::size_t);    // used by new
void * operator new[](std::size_t);    // used by new[]
void operator delete(void *);
void operator delete[](void *);
int * pi = new int;
int * pi = new(sizeof(int));
];
 * sizeof(int));
delete pi;
delete (pi);

#include <new>
struct chaff {
    ];
    int slag;
};
];
];

int main() {
    chaff * p1, * p2;
    int * p3, * p4;
// first, the regular forms of new
    p1 = new chaff;    // place structure in heap
    p3 = ];    // place int array in heap
// now, the two forms of placement new
    p2 = new (buffer1) chaff;    // place structure in buffer1
    p4 = ];    // place int array in buffer2

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <new>

;
;
char buffer[BUF];

int main() {
    using namespace std;
    double * pd1, * pd2;
    int i;
    cout << "Calling new and placement new:\n";
    pd1 = new double[N];    // use heap
    pd2 = new (buffer) double[N];    // use buffer array

    ; i < N; i++) {
        pd2[i] = pd1[i] =  + 20.0 * i;
    }

    cout << "Memory address:\n" << " heap: " << pd1
        << " static: " << (void *)buffer << endl;

    cout << "Memory contents:\n";

    ; i < N; i++) {
        cout << pd1[i] << " at " << &pd1[i] << "; ";
        cout << pd2[i] << " at " << &pd2[i] << endl;
    }

    cout << "\nCalling new and placement new a second time:\n";
    double * pd3, * pd4;
    pd3 = new double[N];    // find new address
    pd4 = new (buffer) double[N];    // overwrite old data
    ; i < N; i++) {
        pd4[i] = pd3[i] =  + 40.0 * i;
    }
    cout << "Memory contents:\n";
    ; i < N; i++) {
        cout << pd3[i] << " at " << &pd3[i] << "; ";
        cout << pd4[i] << " at " << &pd4[i] << endl;
    }
    cout << "\nCalling new and placement new a third time:\n";
    delete[] pd1;
    pd1 = new double[N];
    pd2 = new (buffer + N * sizeof(double)) double[N];
    ; i < N; i++) {
        pd2[i] = pd1[i] =  + 60.0 * i;
    }
    cout << "Memory contents:\n";
    ; i < N; i++) {
        cout << pd1[i] << " at " << &pd1[i] << "; ";
        cout << pd2[i] << " at " << &pd2[i] << endl;
    }
    delete[] pd1;
    delete[] pd3;

    cin.get();
    cin.get();

    ;
}

// namesp.h
#include <string>

namespace pers {
    struct Person {
        std::string fname;
        std::string lname;
    };

    void getPerson(Person &);
    void showPerson(const Person &);
}

namespace debts {
    using namespace pers;
    struct Debt {
        Person name;
        double amount;
    };
    void getDebt(Debt &);
    void showDebt(const Debt &);
    double sumDebts(const Debt ar[], int n);
}

// namesp.cpp
#include <iostream>
#include "namesp.h"

namespace pers {
    using std::cout;
    using std::cin;
    void getPerson(Person & rp) {
        cout << "Enter first name: ";
        cin >> rp.fname;
        cout << "Enter last name: ";
        cin >> rp.lname;
    }
    void showPerson(const Person & rp) {
        std::cout << rp.lname << ", " << rp.fname;
    }
}

namespace debts {
    void getDebt(Debt & rd) {
        getPerson(rd.name);
        std::cout << "Enter debt: ";
        std::cin >> rd.amount;
    }
    void showDebt(const Debt & rd) {
        showPerson(rd.name);
        std::cout << ": $" << rd.amount << std::endl;
    }
    double sumDebts(const Debt ar[], int n) {
        ;
        ; i < n; i++) {
            total += ar[i].amount;
        }
        return total;
    }
}

// usenmsp.cpp
#include <iostream>
#include "namesp.h"

void other(void);
void another(void);

int main(void) {
    using debts::Debt;
    using debts::showDebt;

    Debt golf = { { "Benny", "Goatsniff" }, 120.0 };
    showDebt(golf);
    other();
    another();

    ;
}

void other(void) {
    using std::cout;
    using std::endl;
    using namespace debts;
    Person dg = { "Doodles", "Glister" };
    showPerson(dg);
    cout << endl;
    Debt zippy[];
    int i;
    ; i < ; i++) {
        getDebt(zippy[i]);
    }
    ; i < ; i++) {
        showDebt(zippy[i]);
    }
    cout << ) << endl;

    return;
}

void another(void) {
    using pers::Person;
    Person collector = { "Milo", "Rightshift" };
    pers::showPerson(collector);
    std::cout << std::endl;
}

#ifndef STOCK00_H_
#define STOCK00_H_

#include <string>

class Stock {
private:
    std::string company;
    long shares;
    double share_val;
    double total_val;
    void set_tot() { total_val = shares * share_val; }
public:
    void accuire(const std::string & co, long n, double pr);
    void buy(long num, double price);
    void sell(long num, double price);
    void update(double price);
    void show();
};

#endif

#include <iostream>
#include "stock00.h"

void Stock::accquire(const std::string & co, long n, double pr) {
    company = co;
    ) {
        std::cout << "Number of shares can't be negative; "
            << company << " shares set to 0.\n";
        shares = ;
    } else {
        shares = n;
    }
    share_val = pr;
    set_tot();
}

void Stock::buy(long num, double price) {
    ) {
        std::cout << "Number of shares purchased can't be negative."
            << "Transaction is aborted.\n";
    } else {
        shares += num;
        share_val = price;
        set_tot();
    }
}

void Stock::sell(long num, double price) {
    using std::cout;
    ) {
        cout << "Number of shares sold can't be negative."
            << "Transaction is aborted.\n";
    } else if (num > shares) {
        cout << "You can't sell more than you have! "
            << "Transaction is aborted.\n";
    } else {
        shares -= num;
        share_val = price;
        set_tot();
    }
}

void Stock::show() {
    std::cout << "Company: " << company
        << " Shares: " << shares << '\n'
        << " Share Price: $" << share_val
        << " Total Worth: $" << total_val << '\n';
}

#include <iostream>
#include "stock00.h"

int main() {
    Stock fluffy_the_cat;
    fluffy_the_cat.acquire(, 12.50);
    fluffy_the_cat.show();
    fluffy_the_cat.buy(, 18.125);
    fluffy_the_cat.show();
    fluffy_the_cat.sell(, 20.00);
    fluffy_the_cat.show();
    fluffy_the_cat.buy(, 40.125);
    fluffy_the_cat.show();
    fluffy_the_cat.sell(, 0.125);
    fluffy_the_cat.show();

    ;
}

#ifndef STOCK10_H_
#define STOCK10_H_

#include <string>

class Stock {
private:
    std::string company;
    long shares;
    double share_val;
    double total_val;
    void set_tot() {
        total_val = shares * share_val;
    }
public:
    Stock();
    Stock(, double pr = 0.0);
    ~Stock();
    void buy(long num, double price);
    void sell(long num, double price);
    void update(double price);
    void show();
};

#endif

#include <iostream>
#include "stock10.h"

Stock::Stock() {
    std::cout << "Default constructor called\n";
    company = "no name";
    shares = ;
    share_val = 0.0;
    total_val = 0.0;
}

Stock::Stock(const std::string & co, long n, double pr) {
    std::cout << "Constructor using " << co << " called\n";
    company = co;

    ) {
        std::cout << "Number of shares can't be negative; "
            << company << " shares set to 0.\n";
        shares = ;
    } else {
        shares = n;
    }

    share_val = pr;
    set_tot();
}

Stock::~Stock() {
    std::cout << "Bye, " << company << "!\n";
}

void Stock::buy(long num, double price) {
    ) {
        std::cout << "Number of shares purchased can't be negative. "
            << "Transaction is aborted.\n";
    } else {
        shares += num;
        share_val = price;
        set_tot();
    }
}

void Stock::sell(long num, double price) {
    using std::cout;
    ) {
        cout << "Number of shares sold can't be negative. "
            << "Transaction is aborted.\n";
    } else if (num > shares) {
        cout << "You can't sell more than you have! "
            << "Transaction is aborted.\n";
    } else {
        shares -= num;
        share_val = price;
        set_tot();
    }
}

void Stock::update(double price) {
    share_val = price;
    set_tot();
}

void Stock::show() {
    using std::cout;
    using std::ios_base;

    ios_base::fmtflags orig = cout.setf(ios_base::fixed, ios_base::floatfield);
    std::streamsize prec = cout.precision();

    cout << "Company: " << company
        << " Shares: " << shares << '\n';
    cout << " Share Price: $" << share_val;

    cout.precision();
    cout << " Total Worth: $" << total_val << '\n';

    cout.setf(orig, ios_base::floatfield);
    cout.precision(prec);
}

#include <iostream>
#include "stock10.h"

int main() {
    {
        using std::cout;
        cout << "Using constructors to create new objects\n";
        Stock stock1(, 20.0);
        stock1.show();
        Stock stock2 = Stock(, 2.0);
        stock2.show();

        cout << "Assigning stock1 to stock2:\n";
        stock2 = stock1;
        cout << "Listing stock1 and stock2:\n";
        stock1.show();
        stock2.show();

        cout << "Using a constructor to reset an object\n";
        stock1 = Stock(, 50.0);
        cout << "Revised stock1:\n";
        stock1.show();
        cout << "Done\n";

    }

    std::cin.get();
    std::cin.get();

    ;
}

#ifndef STOCK20_H_
#define STOCK20_H_

#include <string>

class Stock {
private:
    std::string company;
    int shares;
    double share_val;
    double total_val;
    void set_tot() { total_val = shares * share_val; }
public:
    Stock();
    Stock(, double pr = 0.0);
    ~Stock();
    void buy(long num, double price);
    void sell(long num, double price);
    void update(double price);
    void show() const;
    const Stock & topval(const Stock & s) const;
};

#endif

#include <iostream>
#include "stock20.h"

Stock::Stock() {
    company = "no name";
    shares = ;
    share_val = 0.0;
    total_val = 0.0;
}

Stock::Stock(const std::string & co, long n, double pr) {
    company = co;
    ) {
        std::cout << "Number of shares can't be negative; "
            << company << " shares set to 0.\n";
        shares = ;
    } else {
        shares = n;
    }
    share_val = pr;
    set_tot();
}

Stock::~Stock() {

}

void Stock::buy(long num, double price) {
    ) {
        std::cout << "Number of shares purchased can't be negative. "
            << "Transaction is aborted.\n";
    } else {
        shares += num;
        share_val = price;
        set_tot();
    }
}

void Stock::sell(long num, double price) {
    using std::cout;
    ) {
        cout << "Number of shares sold can't be negative. "
            << "Transaction is aborted.\n";
    } else if (num > shares) {
        cout << "You can't sell more than you have! "
            << "Transaction is aborted.\n";
    } else {
        shares -= num;
        share_val = price;
        set_tot();
    }
}

void Stock::update(double price) {
    share_val = price;
    set_tot();
}

void Stock::show() const {
    using std::cout;
    using std::ios_base;
    ios_base::fmtflags orig = cout.setf(ios_base::fixed, ios_base::floatfield);
    std::streamsize prec = cout.precision();

    cout << "Company: " << company
        << " Shares: " << shares << '\n';
    cout << " Share Price: $" << share_val;

    cout.precision();
    cout << " Total Worth: $" << total_val << '\n';

    cout.setf(orig, ios_base::floatfield);
    cout.precision(prec);
}

const Stock & Stock::topval(const Stock & s) const {
    if (s.total_val > total_val) {
        return s;
    } else {
        return *this;
    }
}

class Bakery {
private:
    };
    double costs[Months];
...

class Bakery {
private:
    ;
    double costs[Months];
...

#ifndef STACK_H_
#define STACK_H_

typedef unsigned long Item;

class Stack {
private:
     };
    Item items[MAX];
    int top;
public:
    Stack();
    bool isempty() const;
    bool isfull() const;

    bool push(const Item & item);
    bool pop(Item & item);
};

#endif

#include "stack.h"

Stack::Stack() {
    top = ;
}

bool Stack::isempty() const {
    ;
}

bool Stack::isfull() const {
    return top == MAX;
}

bool Stack::push(const Item & item) {
    if (top < MAX) {
        items[top++] = item;
        return true;
    } else {
        return false;
    }
}

bool Stack::pop(Item & item) {
    ) {
        item = items[--top];
        return true;
    } else {
        return false;
    }
}

#include <iostream>
#include <cctype>
#include "stack.h"

int main() {
    using namespace std;
    Stack st;
    char ch;
    unsigned long po;
    cout << "Please enter A to add a purchase order,\n"
        << "P to process a PO, or Q to quit.\n";
    while (cin >> ch && toupper(ch) != 'Q') {
        while (cin.get() != '\n') {
            continue;
        }
        if (!isalpha(ch)) {
            cout << '\a';
            continue;
        }
        switch (ch) {
        case 'A':
        case 'a':
            cout << "Enter a PO number to add: ";
            cin >> po;
            if (st.isfull()) {
                cout << "stack already full\n";
            } else {
                st.push(po);
            }
            break;
        case 'P':
        case 'p':
            if (st.isempty()) {
                cout << "stack already empty\n";
            } else {
                st.pop(po);
                cout << "PO #" << po << " popped\n";
            }
            break;
        }
        cout << "Please enter A to add a purchase order,\n"
            << "P to process a PO, or Q to quit.\n";
    }
    cout << "Bye\n";

    ;
}

// mytime0.h
#ifndef MYTIME0_H_
#define MYTIME0_H_

class Time {
private:
    int hours;
    int minutes;
public:
    Time();
    Time();
    void AddMin(int m);
    void AddHr(int h);
    , );
    Time Sum(const Time & t) const;
    void Show() const;
};

#endif

// mytime0.cpp
#include <iostream>
#include "mytime0.h"

Time::Time() {
    hours = minutes = ;
}

Time::Time(int h, int m) {
    hours = h;
    minutes = m;
}

void Time::AddMin(int m) {
    minutes += m;
    hours += minutes / ;
    minutes %= ;
}

void Time::AddHr(int h) {
    hours += h;
}

void Time::Reset(int h, int m) {
    hours = h;
    minutes = m;
}

Time Time::Sum(const Time & t) const {
    Time sum;
    sum.minutes = minutes + t.minutes;
    sum.hours = hours + t.hours + sum.minutes / ;
    sum.minutes %= ;
    return sum;
}

#include <iostream>
#include "mytime0.h"

int main() {
    using std::cout;
    using std::endl;

    Time palnning;
    Time coding(, );
    Time fixing(, );
    Time total;

    cout << "planning time = ";
    palnning.Show();
    cout << endl;

    cout << "coding time = ";
    coding.Show();
    cout << endl;

    cout << "fixing time = ";
    fixing.Show();
    cout << endl;

    total = coding.Sum(fixing);
    cout << "coding.Sum(fixing) = ";
    total.Show();
    cout << endl;

    ;
}

// mytime1.h
#ifndef MYTIME0_H_
#define MYTIME0_H_

class Time {
private:
    int hours;
    int minutes;
public:
    Time();
    Time();
    void AddMin(int m);
    void AddHr(int h);
    , );
    Time operator+(const Time & t) const;
    void Show() const;
};

#endif

// mytime1.cpp
#include <iostream>
#include "mytime1.h"

Time::Time() {
    hours = minutes = ;
}

Time::Time(int h, int m) {
    hours = h;
    minutes = m;
}

void Time::AddMin(int m) {
    minutes += m;
    hours += minutes / ;
    minutes %= ;
}

void Time::AddHr(int h) {
    hours += h;
}

void Time::Reset(int h, int m) {
    hours = h;
    minutes = m;
}

Time Time::operator+(const Time & t) const {
    Time sum;
    sum.minutes = minutes + t.minutes;
    sum.hours = hours + t.hours + sum.minutes / ;
    sum.minutes %= ;
    return sum;
}

void Time::Show() const {
    std::cout << hours << " hours, " << minutes << " minutes";
}

#include <iostream>
#include "mytime1.h"

int main() {
    using std::cout;
    using std::endl;
    Time planning;
    Time coding(, );
    Time fixing(, );
    Time total;

    cout << "planning time = ";
    planning.Show();
    cout << endl;

    cout << "coding time = ";
    coding.Show();
    cout << endl;

    cout << "fixing time = ";
    fixing.Show();
    cout << endl;

    total = coding + fixing;
    cout << "coding + fixing = ";
    total.Show();
    cout << endl;

    Time morefixing(, );
    cout << "more fixing time = ";
    morefixing.Show();
    cout << endl;
    total = morefixing.operator+(total);
    cout << "morefixing.operator+(total) = ";
    total.Show();
    cout << endl;

    ;
}

#ifndef MYTIME3_H_
#define MYTIME3_H_

#include <iostream>

class Time {
private:
    int hours;
    int minutes;
public:
    Time();
    Time();
    void AddMin(int m);
    void AddHr(int h);
    , );
    Time operator+(const Time & t) const;
    Time operator-(const Time & t) const;
    Time operator*(double n) const;
    friend Time operator*(double m, const Time & t) {
        return t * m;
    }
    friend std::ostream & operator<<(std::ostream & os, const Time & t);
};

#endif

#include "mytime3.h"

Time::Time() {
    hours = minutes = ;
}

Time::Time(int h, int m) {
    hours = h;
    minutes = m;
}

void Time::AddMin(int m) {
    minutes += m;
    hours += minutes / ;
    minutes %= ;
}

void Time::AddHr(int h) {
    hours += h;
}

void Time::Reset(int h, int m) {
    hours = h;
    minutes = m;
}

Time Time::operator+(const Time & t) const {
    Time sum;
    sum.minutes = minutes + t.minutes;
    sum.hours = hours + t.hours + sum.minutes / ;
    sum.minutes %= ;
    return sum;
}

Time Time::operator-(const Time & t) const {
    Time diff;
    int tot1, tot2;
    tot1 = t.minutes +  * t.hours;
    tot2 = minutes +  * hours;
    diff.minutes = (tot2 - tot1) % ;
    diff.hours = (tot2 - tot1) / ;
    return diff;
}

Time Time::operator*(double mult) const {
    Time result;
     + minutes * mult;
    result.hours = totalminutes / ;
    result.minutes = totalminutes % ;
    return result;
}

std::ostream & operator<<(std::ostream & os, const Time & t) {
    os << t.hours << " hours, " << t.minutes << " minutes";
    return os;
}

#include <iostream>
#include "mytime3.h"

int main() {
    using std::cout;
    using std::endl;
    Time aida(, );
    Time tosca(, );
    Time temp;

    cout << "Aida and Tosca:\n";
    cout << aida << "; " << tosca << endl;
    temp = aida + tosca;
    cout << "Aida + Tosca: " << temp << endl;
    temp = aida * 1.17;
    cout << "Aida * 1.17: " << temp << endl;
    cout << "10.0 * Tosca: " << 10.00 * tosca << endl;

    std::cin.get();

    ;
}

#ifndef VECTOR_H_
#define VECTOR_H_

#include <iostream>

namespace VECTOR {
    class Vector {
    public:
        enum Mode { RECT, POL };    // RECT for rectangular, POL for Polar modes
    private:
        double x;
        double y;
        double mag;
        double ang;
        Mode mode;

        void set_mag();
        void set_ang();
        void set_x();
        void set_y();
    public:
        Vector();
        Vector(double n1, double n2, Mode form = RECT);
        void reset(double n1, double n2, Mode form = RECT);
        ~Vector();
        double xval() const { return x; }
        double yval() const { return y; }
        double magval() const { return mag; }
        double angval() const { return ang; }
        void polar_mode();
        void rect_mode();

        Vector operator+(const Vector & b) const;
        Vector operator-(const Vector & b) const;
        Vector operator-() const;
        Vector operator*(double n) const;

        friend Vector operator*(double n, const Vector & a);
        friend std::ostream & operator<<(std::ostream & os, const Vector &v);
    };
}

#endif

#include <cmath>
#include "vector.h"

using std::sqrt;
using std::sin;
using std::cos;
using std::atan;
using std::atan2;
using std::cout;

namespace VECTOR {
    const double Rad_to_deg = 45.0 / atan(1.0);

    void Vector::set_mag() {
        mag = sqrt(x * x + y * y);
    }

    void Vector::set_ang() {
        if (x == 0.0 && y == 0.0) {
            ang = 0.0;
        } else {
            ang = atan2(y, x);
        }
    }

    void Vector::set_x() {
        x = mag * cos(ang);
    }

    void Vector::set_y() {
        y = mag * sin(ang);
    }

    Vector::Vector() {
        x = y = mag = ang = 0.0;
        mode = RECT;
    }

    Vector::Vector(double n1, double n2, Mode form) {
        mode = form;
        if (form == RECT) {
            x = n1;
            y = n2;
            set_mag();
            set_ang();
        } else if (form == POL) {
            mag = n1;
            ang = n2 / Rad_to_deg;
        } else {
            cout << "Incorrect 3rd argument to Vector() -- ";
            cout << "vector set to 0\n";
            x = y = mag = ang = 0.0;
            mode = RECT;
        }
    }

    void Vector::reset(double n1, double n2, Mode form) {
        mode = form;
        if (form == RECT) {
            x = n1;
            y = n2;
            set_mag();
            set_ang();
        } else if (form == POL) {
            mag = n1;
            ang = n2 / Rad_to_deg;
            set_x();
            set_y();
        } else {
            cout << "Incorrect 3rd argument to Vector() -- ";
            cout << "vector set to 0\n";
            x = y = mag = ang = 0.0;
            mode = RECT;
        }
    }

    Vector::~Vector() {

    }

    void Vector::polar_mode() {
        mode = POL;
    }

    void Vector::rect_mode() {
        mode = RECT;
    }

    Vector Vector::operator+(const Vector & b) const {
        return Vector(x + b.x, y + b.x);
    }

    Vector Vector::operator-(const Vector & b) const {
        return Vector(x - b.x, y - b.y);
    }

    Vector Vector::operator-() const {
        return Vector(-x, -y);
    }

    Vector Vector::operator*(double n) const {
        return Vector(n * x, n * y);
    }

    Vector operator*(double n, const Vector & a) {
        return a * n;
    }

    std::ostream & operator<<(std::ostream & os, const Vector & v) {
        if (v.mode == Vector::RECT) {
            os << "(x,y) = (" << v.x << ", " << v.y << ")";
        } else if (v.mode == Vector::POL) {
            os << "(m,a) = (" << v.mag << ", "
                << v.ang * Rad_to_deg << ")";
        } else {
            os << "Vector object mode is invalid";
        }
        return os;
    }

}

#include <iostream>
#include <cstdlib>
#include <ctime>
#include "vector.h"

int main() {
    using namespace std;
    using VECTOR::Vector;
    srand(time());
    double direction;
    Vector step;
    Vector result(0.0, 0.0);
    unsigned ;
    double target;
    double dstep;
    cout << "Enter target distance (q to quit): ";
    while (cin >> target) {
        cout << "Enter step length: ";
        if (!(cin >> dstep)) {
            break;
        }

        while (result.magval() < target) {
            direction = rand() % ;
            step.reset(dstep, direction, Vector::POL);
            result = result + step;
            steps++;
        }

        cout << "After " << steps << " steps, the subject "
            "has the following location:\n";
        cout << result << endl;
        result.polar_mode();
        cout << " or\n" << result << endl;
        cout << "Averange outward distance per step = "
            << result.magval() / steps << endl;
        steps = ;
        result.reset(0.0, 0.0);
        cout << "Enter target distance (q to quit): ";
    }
    cout << "Bye\n";
    cin.clear();
    while (cin.get() != '\n') {
        continue;
    }

    ;
}

#ifndef STONEWT_H_
#define STONEWT_H_

class Stonewt {
private:
     };
    int stone;
    double pds_left;
    double pounds;
public:
    Stonewt(double lbs);
    Stonewt(int stn, double lbs);
    Stonewt();
    ~Stonewt();

    void show_lbs() const;
    void show_stn() const;
};

#endif

#include <iostream>
#include "stonewt.h"

using std::cout;

Stonewt::Stonewt(double lbs) {
    stone = int(lbs) / Lbs_per_stn;
    pds_left = int(lbs) % Lbs_per_stn + lbs - int(lbs);
    pounds = lbs;
}

Stonewt::Stonewt(int stn, double lbs) {
    stone = stn;
    pds_left = lbs;
    pounds = stn * Lbs_per_stn + lbs;
}

Stonewt::Stonewt() {
    stone = pounds = pds_left = ;
}

Stonewt::~Stonewt() {

}

void Stonewt::show_stn() const {
    cout << stone << " stone, " << pds_left << " pounds\n";
}

void Stonewt::show_lbs() const {
    cout << pounds << " pounds\n";
}

#include <iostream>
#include "stonewt.h"

using std::cout;

void display(const Stonewt & st, int n);

int main() {
    Stonewt incognito = ;
    Stonewt wolfe(285.7);
    Stonewt taft(, );

    cout << "The celebrity weighed ";
    incognito.show_stn();
    cout << "The detective weighed ";
    wolfe.show_stn();
    cout << "The President weighed ";
    taft.show_lbs();

    incognito = 276.8;    // use constructor for conversion;
    taft = ;
    cout << "After dinner, the celebrity weighed ";
    incognito.show_stn();
    cout << "After dinner, the President weighed ";
    taft.show_lbs();
    display(taft, );
    cout << "The wrestler weighed even more.\n";
    display(, );
    cout << "No stone left unearned\n";

    std::cin.get();

    ;
}

void display(const Stonewt & st, int n) {
    ; i < n; i++) {
        cout << "Wow!";
        st.show_stn();
    }
}

#ifndef STONEWT_H_
#define STONEWT_H_

class Stonewt {
private:
     };
    int stone;
    double pds_left;
    double pounds;
public:
    Stonewt(double lbs);
    Stonewt(int stn, double lbs);
    Stonewt();
    ~Stonewt();

    void show_lbs() const;
    void show_stn() const;

    operator int() const;
    operator double() const;
};

#endif

#include <iostream>
#include "stonewt.h"

using std::cout;

Stonewt::Stonewt(double lbs) {
    stone = int(lbs) / Lbs_per_stn;
    pds_left = int(lbs) % Lbs_per_stn + lbs - int(lbs);
    pounds = lbs;
}

Stonewt::Stonewt(int stn, double lbs) {
    stone = stn;
    pds_left = lbs;
    pounds = stn * Lbs_per_stn + lbs;
}

Stonewt::Stonewt() {
    stone = pounds = pds_left = ;
}

Stonewt::~Stonewt() {

}

void Stonewt::show_stn() const {
    cout << stone << " stone, " << pds_left << " pounds\n";
}

void Stonewt::show_lbs() const {
    cout << pounds << " pounds\n";
}

Stonewt::operator int() const {
    return int(pounds + 0.5);
}

Stonewt::operator double() const {
    return pounds;
}

#include <iostream>
#include "stonewt.h"

int main() {
    using std::cout;

    Stonewt popins(, 2.8);
    double p_wt = popins;
    cout << "Convert to double => ";
    cout << "Poppins: " << p_wt << " pounds.\n";
    cout << "Convert to int => ";
    cout << "Poppins: " << int(popins) << " pounds.\n";

    std::cin.get();

    ;
}

#ifndef STRINGBAD_H_
#define STRINGBAD_H_

#include <iostream>

class StringBad {
private:
    char * str;
    int len;
    static int num_strings;
public:
    StringBad(const char * s);
    StringBad();
    ~StringBad();

    friend std::ostream & operator<<(std::ostream & os, const StringBad & st);
};

#endif

#define _CRT_SECURE_NO_WARNINGS

#include <cstring>
#include "stringbad.h"

using std::cout;

;

StringBad::StringBad(const char * s) {
    len = std::strlen(s);
    str = ];
    std::strcpy(str, s);
    num_strings++;
    cout << num_strings << ": \"" << str
        << "\" object created\n";
}

StringBad::StringBad() {
    len = ;
    str = ];
    std::strcpy(str, "C++");
    num_strings++;
    cout << num_strings << ": \"" << str
        << "\" default object created\n";
}

StringBad::~StringBad() {
    cout << "\"" << str << "\" object deleted, ";
    --num_strings;
    cout << num_strings << " left\n";
    delete[] str;
}

std::ostream & operator<<(std::ostream & os, const StringBad & st) {
    os << st.str;
    return os;
}

#include <iostream>
#include "stringbad.h"
using std::cout;

void callme1(StringBad &);
void callme2(StringBad);

int main() {
    using std::endl;
    {
        cout << "Starting an inner block.\n";
        StringBad headline1("Celery Stalks at Midnight");
        StringBad headline2("Lettuce Prey");
        StringBad sports("Spinach Leaves Bowl for Dollars");

        cout << "headline1: " << headline1 << endl;
        cout << "headlien2: " << headline2 << endl;
        cout << "sports: " << sports << endl;
        callme1(headline1);
        cout << "headline1: " << headline1 << endl;
        callme2(headline2);
        cout << "headline2: " << headline2 << endl;
        cout << "Initialize one object to another:\n";
        StringBad sailor = sports;
        cout << "sailor: " << sailor << endl;
        cout << "Assign one object to another:\n";
        StringBad knot;
        knot = headline1;
        cout << "knot: " << knot << endl;
        cout << "Exiting the block.\n";
    }

    cout << "End of main()\n";

    std::cin.get();

    ;
}

void callme1(StringBad & rsb) {
    cout << "String passed by reference:\n";
    cout << "  \"" << rsb << "\"\n";
}

void callme2(StringBad sb) {
    cout << "String passed by value:\n";
    cout << "  \"" << sb << "\"\n";
}

StringBad ditto(motto);    // calls StringBad(const StringBad &)
StringBad metoo = motto);    // calls StringBad(const StringBad &)
StringBad also = StringBad(motto);    // calls StringBad(const StringBad &)
StringBad * pStringBad = new StringBad(motto);    // calls StringBad(const StringBad &)

#ifndef STRING1_H_
#define STRING1_H_

#include <iostream>

using std::ostream;
using std::istream;

class String {
private:
    char * str;    // pointer to string
    int len;    // length of string
    static int num_strings;    // number of objects
    ;    // cin input limit
public:
    // constructor and other methods
    String(const char * s);    // constructor
    String();    // default constructor
    String(const String &);    // copy constructor
    ~String();    // destructor

    int length() const { return len; }

    // overloaded operator methods
    String & operator=(const String &);
    String & operator=(const char *);
    char & operator[](int i);
    const char & operator[](int i) const;

    // overloaded operator friends
    friend bool operator<(const String &st, const String &st2);
    friend bool operator>(const String &st1, const String &st2);
    friend bool operator==(const String &st1, const String &st2);
    friend ostream & operator<<(ostream & os, const String &st);
    friend istream & operator>>(istream & is, String & st);

    // static function
    static int HowMany();
};

#endif

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include "string1.h"

using std::cin;
using std::cout;

;

int String::HowMany() {
    return num_strings;
}

String::String(const char * s) {
    len = std::strlen(s);
    str = ];
    std::strcpy(str, s);
    num_strings++;
}

String::String() {
    len = ;
    str = ];
    str[] = '\0';
    num_strings++;
}

String::String(const String & st) {
    num_strings++;
    len = st.len;
    str = ];
    std::strcpy(str, st.str);
}

String::~String() {
    --num_strings;
    delete[] str;
}

String & String::operator=(const String & st) {
    if (this == &st) {
        return *this;
    }

    delete[] str;
    len = st.len;
    str = ];
    std::strcpy(str, st.str);
    return *this;
}

String & String::operator=(const char * s) {
    delete[] str;
    len = std::strlen(s);
    str = ];
    std::strcpy(str, s);
    return *this;
}

char & String::operator[](int i) {
    return str[i];
}

const char & String::operator[](int i) const {
    return str[i];
}

bool operator<(const String & st1, const String & st2) {
    );
}

bool operator>(const String & st1, const String & st2) {
    return st2 < st1;
}

bool operator==(const String & st1, const String & st2) {
    );
}

ostream & operator<<(ostream & os, const String & st) {
    os << st.str;
    return os;
}

istream & operator>>(istream & is, String & st) {
    char temp[String::CINLIM];
    is.get(temp, String::CINLIM);
    if (is) {
        st = temp;
    }
    while (is && is.get() != '\n') {
        continue;
    }
    return is;
}

#include <iostream>
#include "string1.h"

;
;

int main() {
    using std::cout;
    using std::cin;
    using std::endl;
    String name;
    cout << "Hi, what's your name?\n>>";
    cin >> name;
    cout << name << ", please enter up to " << ArSize
        << " short saying <empty line to quit>:\n";
    String sayings[ArSize];
    char temp[MaxLen];
    int i;
    ; i < ArSize; i++) {
        cout << i +  << ": ";
        cin.get(temp, MaxLen);
        while (cin && cin.get() != '\n') {
            continue;
        }
        ] == '\0') {
            break;
        } else {
            sayings[i] = temp;
        }
    }
    int total = i;

    ) {
        cout << "Here are your sayings:\n";
        ; i < total; i++) {
            cout << sayings[i][] << ": " << sayings[i] << endl;
        }

        ;
        ;
        ; i < total; i++) {
            if (sayings[i].length() < sayings[shortest].length()) {
                shortest = i;
            }
            if (sayings[i] < sayings[first]) {
                first = i;
            }
        }

        cout << "Shortest saying:\n" << sayings[shortest] << endl;
        cout << "First alphabetically:\n" << sayings[first] << endl;
        cout << "This program used " << String::HowMany()
            << " String objects. Bye.\n";
    } else {
        cout << "No input! Bye.\n";
    }

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <string>
#include <new>

using namespace std;
;

class JustTesting {
private:
    string words;
    int number;
public:
    JustTesting() {
        words = s;
        number = n;
        cout << words << " constructed\n";
    }
    ~JustTesting() {
        cout << words << " destroyed\n";
    }
    void Show() const {
        cout << words << ", " << number << endl;
    }
};

int main() {
    char * buffer = new char[BUF];    // get block of memory

    JustTesting * pc1, * pc2;

    pc1 = new (buffer) JustTesting;    // place object in buffer
    pc2 = );    // place object on heap

    cout << "Memory block address:\n" << "buffer: "
        << (void *)buffer << "    heap:" << pc2 << endl;
    cout << "Memory contents:\n";
    cout << pc1 << ": ";
    pc1->Show();
    cout << pc2 << ": ";
    pc2->Show();

    JustTesting * pc3, * pc4;
    pc3 = );
    pc4 = );

    cout << "Memory contents:\n";
    cout << pc3 << ": ";
    pc3->Show();
    cout << pc4 << ": ";
    pc4->Show();

    delete pc2;    // free Heap1
    delete pc4;    // free Heap2

    pc3->~JustTesting();    // destroy object pointed to by pc3
    pc1->~JustTesting();    // destroy object pointed to by pc1

    delete[] buffer;    // free buffer;

    cout << "Done\n";

    cin.get();

    ;
}

#ifndef QUEUE_H_
#define QUEUE_H_

class Customer {
private:
    long arrive;    //arrival time for customer
    int processtime;    // processing time for customer
public:
    Customer() {
        arrive = processtime = ;
    }
    void set(long when);
    long when() const {
        return arrive;
    }
    int ptime() const {
        return processtime;
    }
};

typedef Customer Item;

class Queue {
private:
    // class scope definitions
    // Node is a nested structure definition local to this c
    struct Node {
        Item item;
        struct Node * next;
    };
    enum {
        Q_SIZE =
    };
    // private class members
    Node * front;    // pointer to front of Queue
    Node * rear;    // pointer to rear of Queue
    int items;    // current number of items in Queue
    const int qsize;    // maximum number of items in Queue
    // preemptive definitions to prevent public copying
    Queue() {}
    Queue & operator=(const Queue & q) {
        return *this;
    }
public:
    Queue(int qs = Q_SIZE);    // create queue with a qs limit
    ~Queue();
    bool isempty() const;
    bool isfull() const;
    int queuecount() const;
    bool enqueue(const Item & item);    // add item to end
    bool dequeue(Item & item);    // remove item from front
};

#endif

#include "queue.h"
#include <cstdlib>

Queue::Queue(int qs) : qsize(qs) {
    front = rear = NULL;    // or nullptr
    items = ;
}

Queue::~Queue() {
    Node * temp;
    while (front != NULL) {    // while queue is not yet empty
        temp = front;    // save address of front item
        front = front->next;    // reset pointer to next item
        delete temp;    // delete former front
    }
}

bool Queue::isempty() const {
    ;
}

bool Queue::isfull() const {
    return items == qsize;
}

int Queue::queuecount() const {
    return items;
}

// Add item to queue
bool Queue::enqueue(const Item & item) {
    if (isfull()) {
        return false;
    }
    Node * add = new Node;    // create node
    // on failure, new throws std::bad_alloc exception
    add->item = item;    // set node pointers
    add->next = NULL;    // or nullptr
    items++;
    if (front == NULL) {    // if queue is empty, place item at front
        front = add;
    } else {
        rear->next = add;    // else place at rear
    }
    rear = add;
    return true;
}

// Place front item into item variable and remove from queue
bool Queue::dequeue(Item & item) {
    if (front == NULL) {
        return false;
    }
    item = front->item;    // set item to first item in queue
    items--;
    Node * temp = front;    // save location of first item
    front = front->next;    // reset front to next item
    delete temp;    // delete former first item
    ) {
        rear = NULL;
    }
    return true;
}

// time set to a random value in the range 1 - 3
void Customer::set(long when) {
    processtime = std::rand() %  + ;
    arrive = when;
}

#include <iostream>
#include <cstdlib>
#include <ctime>
#include "queue.h"

;

bool newcustomer(double x);    // is there a new customer?

int main() {
    using std::cin;
    using std::cout;
    using std::endl;
    using std::ios_base;
    //setting things up
    std::srand(std::time());    // random initializing of rand()

    cout << "Case Study: Bank of Heather Automatic Teller\n";
    cout << "Enter maximum size of queue: ";
    int qs;
    cin >> qs;
    Queue line(qs);    // line queue holds up to qs people

    cout << "Enter the number of simulation hours: ";
    int hours;    // hours of simulation
    cin >> hours;
    // simulation will run 1 cycle per minute
    long cyclelimit = MIN_PER_HR * hours;    // # of cycles

    cout << "Enter the average number of custormers per hour: ";
    double perhour;    // average # of arrival per hour
    cin >> perhour;
    double min_per_cust;    // average time between arrivals
    min_per_cust = MIN_PER_HR / perhour;

    Item temp;    // new customer data
    ;    // turned away by full queue
    ;    // joined the queue
    ;    // served during the simulation
    ;    // cumulative line length
    ;    // time until autoteller is free
    ;    // cumulative time in line

    // running the simulation
    ; cycle < cyclelimit; cycle++) {
        if (newcustomer(min_per_cust)) {    // have newcomer
            if (line.isfull()) {
                turnaways++;
            } else {
                customers++;
                temp.set(cycle);    // cycle = time of arrival
                line.enqueue(temp);    // add newcomer to line
            }
        }
         && !line.isempty()) {
            line.dequeue(temp);    // attend next customer
            wait_time = temp.ptime();    // for wait_time minutes
            line_wait += cycle - temp.when();
            served++;
        }
        ) {
            wait_time--;
        }
        sum_line += line.queuecount();
    }

    // reporting results
    ) {
        cout << "customers accepted: " << customers << endl;
        cout << "  customers served: " << served << endl;
        cout << "    turnaways: " << turnaways << endl;
        cout << "average queue size: ";
        cout.precision();
        cout.setf(ios_base::fixed, ios_base::floatfield);
        cout << (double)sum_line / cyclelimit << endl;
        cout << " average wait time: "
            << (double)line_wait / served << " minutes\n";
    } else {
        cout << "No customers!\n";
    }
    cout << "Done!\n";

    cin.get();
    cin.get();

}

// x = average time, in minutes, between customers
// return value is true if customer shows up this minute
bool newcustomer(double x) {
    );
}

#ifndef TABTENN0_H_
#define TABTENN0_H_

#include <string>

using std::string;

class TableTennisPlayer {
private:
    string firstname;
    string lastname;
    bool hasTable;
public:
    TableTennisPlayer(const string & fn = "none", const string & ln = "none", bool ht = false);
    void Name() const;
    bool HasTable() const {
        return hasTable;
    }
    void ResetTable(bool v) {
        hasTable = v;
    }
};

#endif

#include "tabtenn0.h"
#include <iostream>

TableTennisPlayer::TableTennisPlayer(const string & fn, const string & ln, bool ht) : firstname(fn), lastname(ln), hasTable(ht) {

}

void TableTennisPlayer::Name() const {
    std::cout << lastname << ", " << firstname;
}

#include <iostream>
#include "tabtenn0.h"

int main() {
    using std::cout;
    TableTennisPlayer player1("Chuck", "Blizzard", true);
    TableTennisPlayer player2("Tara", "Boomdea", false);

    player1.Name();
    if (player1.HasTable()) {
        cout << ": has a table.\n";
    } else {
        cout << ": hasn't a table.\n";
    }

    player2.Name();
    if (player2.HasTable()) {
        cout << ": has a table";
    } else {
        cout << ": hasn't a table.\n";
    }

    std::cin.get();

}

#ifndef TABTENN1_H_
#define TABTENN1_H_

#include <string>
using std::string;

class TableTennisPlayer {
private:
    string firstname;
    string lastname;
    bool hasTable;
public:
    TableTennisPlayer(const string & fn = "none", const string & ln = "none", bool ht = false);
    void Name() const;
    bool HasTable() const {
        return hasTable;
    }
    void ResetTable(bool v) {
        hasTable = v;
    }
};

class RatedPlayer : public TableTennisPlayer {
private:
    unsigned int rating;
public:
    RatedPlayer(unsigned , const string & fn = "none", const string & ln = "none", bool ht = false);
    RatedPlayer(unsigned int r, const TableTennisPlayer & tp);
    unsigned int Rating() const {
        return rating;
    }
    void ResetRating(unsigned int r) {
        rating = r;
    }
};

#endif

#include "tabtenn1.h"
#include <iostream>

TableTennisPlayer::TableTennisPlayer(const string & fn, const string & ln, bool ht) : firstname(fn), lastname(ln), hasTable(ht) {}

void TableTennisPlayer::Name() const {
    std::cout << lastname << ", " << firstname;
}

RatedPlayer::RatedPlayer(unsigned int r, const string & fn, const string & ln, bool ht) : TableTennisPlayer(fn, ln, ht) {
    rating = r;
}

RatedPlayer::RatedPlayer(unsigned int r, const TableTennisPlayer & tp) : TableTennisPlayer(tp), rating(r) {

}

#include <iostream>
#include "tabtenn1.h"

int main() {
    using std::cout;
    using std::endl;
    TableTennisPlayer player1("Tara", "Boomdea", false);
    RatedPlayer rplayer1(, "Mallory", "Duck", true);
    rplayer1.Name();

    if (rplayer1.HasTable()) {
        cout << ": has a table.\n";
    } else {
        cout << ": hasn't a table.\n";
    }
    player1.Name();
    if (player1.HasTable()) {
        cout << ": has a table.\n";
    } else {
        cout << ": hasn't a table.\n";
    }
    cout << "Name: ";
    rplayer1.Name();
    cout << "; Rating: " << rplayer1.Rating() << endl;

    RatedPlayer rplayer2(, player1);
    cout << "Name: ";
    rplayer2.Name();
    cout << "; Rating: " << rplayer2.Rating() << endl;

    std::cin.get();

    ;
}

#ifndef BRASS_H_
#define BRASS_H_

#include <string>

class Brass {
private:
    std::string fullName;
    long acctNum;
    double balance;
public:
    Brass(, double bal = 0.0);
    void Deposit(double amt);
    virtual void Widthdraw(double amt);
    double Balance() const;
    virtual void ViewAcct() const;
    virtual ~Brass() {}
};

class BrassPlus : public Brass {
private:
    double maxLoan;
    double rate;
    double owesBank;
public:
    BrassPlus(, , double r = 0.11125);
    BrassPlus(, double r = 0.11125);
    virtual void ViewAcct() const;
    virtual void Withdraw(double amt);
    void ResetMax(double m) {
        maxLoan = m;
    }
    void ResetRate(double r) {
        rate = r;
    }
    void ResetOwes() {
        owesBank = ;
    }
};

#endif

#include <iostream>
#include "brass.h"

using std::cout;
using std::endl;
using std::string;

typedef std::ios_base::fmtflags format;
typedef std::streamsize precis;
format setFormat();
void restore(format f, precis p);

Brass::Brass(const string & s, long an, double bal) {
    fullName = s;
    acctNum = an;
    balance = bal;
}

void Brass::Deposit(double amt) {
    ) {
        cout << "Negative deposit not allowed; "
            << "deposit is cancelled.\n";
    } else {
        balance += amt;
    }
}

void Brass::Widthdraw(double amt) {
    format initialState = setFormat();
    precis prec = cout.precision();

    ) {
        cout << "Withdrawal amount must be positive; "
            << "withdrawal canceled.\n";
    } else if (amt <= balance) {
        balance -= amt;
    } else {
        cout << "Withdrawal amount of $" << amt
            << " exceeds your balance.\n"
            << "Withdrawal canceled.\n";
    }
    restore(initialState, prec);
}

double Brass::Balance() const {
    return balance;
}

void Brass::ViewAcct() const {
    format initialState = setFormat();
    precis prec = cout.precision();
    cout << "Client: " << fullName << endl;
    cout << "Account Number: " << acctNum << endl;
    cout << "Balance: $" << balance << endl;
    restore(initialState, prec);
}

BrassPlus::BrassPlus(const string & s, long an, double bal, double ml, double r) : Brass(s, an, bal) {
    maxLoan = ml;
    owesBank = 0.0;
    rate = r;
}

BrassPlus::BrassPlus(const Brass & ba, double ml, double r) : Brass(ba) {
    maxLoan = ml;
    owesBank = 0.0;
    rate = r;
}

void BrassPlus::ViewAcct() const {
    format initialState = setFormat();
    precis prec = cout.precision();

    Brass::ViewAcct();
    cout << "Maximum loan: $" << maxLoan << endl;
    cout << "Owed to bank: $" << owesBank << endl;
    cout.precision();
    cout <<  * rate << "%\n";
    restore(initialState, prec);
}

void BrassPlus::Withdraw(double amt) {
    format initialState = setFormat();
    precis prec = cout.precision();

    double bal = Balance();
    if (amt <= bal) {
        Brass::Widthdraw(amt);
    } else if (amt <= bal + maxLoan - owesBank) {
        double advance = amt - bal;
        owesBank += advance * (1.0 + rate);
        cout << "Bank advance: $" << advance << endl;
        cout << "Finace charge: $" << advance * rate << endl;
        Deposit(advance);
        Brass::Widthdraw(amt);
    } else {
        cout << "Credit limit exceeded. Transaction cancelled.\n";
    }
    restore(initialState, prec);
}

format setFormat() {
    return cout.setf(std::ios_base::fixed, std::ios_base::floatfield);
}

void restore(format f, precis p) {
    cout.setf(f, std::ios_base::floatfield);
    cout.precision(p);
}

#include <iostream>
#include "brass.h"

int main() {
    using std::cout;
    using std::endl;

    Brass Piggy(, 4000.00);
    BrassPlus Hoggy(, 3000.00);

    Piggy.ViewAcct();
    cout << endl;

    Hoggy.ViewAcct();
    cout << endl;
    cout << "Depositing $1000 into the Hogg Account:\n";
    Hoggy.Deposit(1000.00);
    cout << "New balance: $" << Hoggy.Balance() << endl;
    cout << "Withdrawing $4200 from the Pigg Account:\n";
    Piggy.Widthdraw(4200.00);
    cout << "Pigg account balance: $" << Piggy.Balance() << endl;
    cout << "Withdrawing $4200 from the Hogg Account:\n";
    Hoggy.Withdraw(4200.00);
    Hoggy.ViewAcct();

    std::cin.get();
    std::cin.get();

    ;
}

#ifndef ACCTABC_H_
#define ACCTABC_H_

#include <iostream>
#include <string>

class AcctABC {
private:
    std::string fullName;
    long acctNum;
    double balance;
protected:
    struct Formatting {
        std::ios_base::fmtflags flag;
        std::streamsize pr;
    };
    const std::string & FullName() const {
        return fullName;
    }
    long AcctNum() const {
        return acctNum;
    }
    Formatting SetFormat() const;
    void Restore(Formatting & f) const;
public:
    AcctABC(, double bal = 0.0);
    void Deposit(double amt);
    ;    // pure virtual function
    double Balance() const { return balance; };
    ;    // pure virtual function
    virtual ~AcctABC() {}
};

class Brass : public AcctABC {
public:
    Brass(, double bal = 0.0) : AcctABC(s, an, bal) {}
    virtual void Withdraw(double amt);
    virtual void ViewAcct() const;
    virtual ~Brass() {}
};

class BrassPlus : public AcctABC {
private:
    double maxLoan;
    double rate;
    double owesBank;
public:
    BrassPlus(, , double r = 0.10);
    BrassPlus(, double r = 0.1);
    virtual void ViewAcct() const;
    virtual void Withdraw(double amt);
    void ResetMax(double m) { maxLoan = m; }
    void ResetRate(double r) { rate = r; }
    ; }
};

#endif

#include <iostream>
#include "acctabc.h"
using std::cout;
using std::ios_base;
using std::endl;
using std::string;

AcctABC::AcctABC(const string & s, long an, double bal) {
    fullName = s;
    acctNum = an;
    balance = bal;
}

void AcctABC::Deposit(double amt) {
    ) {
        cout << "Negative deposit not allowed; "
            << "deposit is cancelled.\n";
    } else {
        balance += amt;
    }
}

void AcctABC::Withdraw(double amt) {
    balance -= amt;
}

AcctABC::Formatting AcctABC::SetFormat() const {
    Formatting f;
    f.flag = cout.setf(ios_base::fixed, ios_base::floatfield);
    f.pr = cout.precision();
    return f;
}

void AcctABC::Restore(Formatting & f) const {
    cout.setf(f.flag, ios_base::floatfield);
    cout.precision(f.pr);
}

void Brass::Withdraw(double amt) {
    ) {
        cout << "Withdrawal amount must be positive: "
            << "withdrawal canceled.\n";
    } else if (amt <= Balance()) {
        AcctABC::Withdraw(amt);
    } else {
        cout << "Withdrawal amount of $" << amt
            << " exceeds your balance.\n"
            << "Withdrawal canceld.\n";
    }
}

void Brass::ViewAcct() const {
    Formatting f = SetFormat();
    cout << "Brass Client: " << FullName() << endl;
    cout << "Account Number: " << AcctNum() << endl;
    cout << "Balance: $" << Balance() << endl;
    Restore(f);
}

BrassPlus::BrassPlus(const string & s, long an, double bal, double ml, double r) : AcctABC(s, an, bal) {
    maxLoan = ml;
    owesBank = 0.0;
    rate = r;
}

BrassPlus::BrassPlus(const Brass & ba, double ml, double r) : AcctABC(ba) {
    maxLoan = ml;
    owesBank = 0.0;
    rate = r;
}

void BrassPlus::ViewAcct() const {
    Formatting f = SetFormat();
    cout << "BrassPlus Client: " << FullName() << endl;
    cout << "Account Number: " << AcctNum() << endl;
    cout << "Balance: $" << Balance() << endl;
    cout << "Maximum loan: $" << maxLoan << endl;
    cout << "Owed to bank: $" << owesBank << endl;
    cout.precision();
    cout <<  * rate << "%\n";
    Restore(f);
}

void BrassPlus::Withdraw(double amt) {
    Formatting f = SetFormat();
    double bal = Balance();
    if (amt <= bal) {
        AcctABC::Withdraw(amt);
    } else if (amt <= bal + maxLoan - owesBank) {
        double advance = amt - bal;
        owesBank += advance * (1.0 + rate);
        cout << "Bank advance: $" << advance << endl;
        cout << "Finance charge: $" << advance * rate << endl;
        Deposit(advance);
        AcctABC::Withdraw(amt);
    } else {
        cout << "Credit limit exceeded. Transaction cancelled.\n";
    }
    Restore(f);
}

#include <iostream>
#include <string>
#include "acctabc.h"

;

int main() {
    using std::cin;
    using std::cout;
    using std::endl;

    AcctABC * p_clients[CLIENTS];
    std::string temp;
    long tempnum;
    double tempbal;
    char kind;

    ; i < CLIENTS; i++) {
        cout << "Enter client's name: ";
        std::getline(cin, temp);
        cout << "Enter client's account number: ";
        cin >> tempnum;
        cout << "Enter opening balance: $";
        cin >> tempbal;
        cout << "Enter 1 for Brass Account or "
            << "2 for BrassPlus Account: ";
        ')) {
            cout << "Enter either 1 or 2: ";
        }
        ') {
            p_clients[i] = new Brass(temp, tempnum, tempbal);
        } else {
            double tmax, trate;
            cout << "Enter the overdraft limit: $";
            cin >> tmax;
            cout << "Enter the interest rate "
                << "as a decimal fraction: ";
            cin >> trate;
            p_clients[i] = new BrassPlus(temp, tempnum, tempbal, tmax, trate);
        }
        while (cin.get() != '\n') {
            continue;
        }
    }

    cout << endl;
    ; i < CLIENTS; i++) {
        p_clients[i]->ViewAcct();
        cout << endl;
    }

    ; i < CLIENTS; i++) {
        delete p_clients[i];
    }

    cout << "Done.\n";

    cin.get();
    cin.get();
}

#ifndef DMA_H_
#define DMA_H_

#include <iostream>

class baseDMA {
private:
    char * label;
    int rating;
public:
    baseDMA();
    baseDMA(const baseDMA & rs);
    virtual ~baseDMA();
    baseDMA & operator=(const baseDMA & rs);
    friend std::ostream & operator<<(std::ostream & os, const baseDMA & rs);
};

// derived class without DMA
// no destructor needed
// uses implicit copy constructor
// uses implicit assignment operator
class lacksDMA : public baseDMA {
private:
     };
    char color[COL_LEN];
public:
    lacksDMA();
    lacksDMA(const char * c, const baseDMA & rs);
    friend std::ostream & operator<<(std::ostream & os, const lacksDMA & rs);
};

class hasDMA : public baseDMA {
private:
    char * style;
public:
    hasDMA();
    hasDMA(const char * s, const baseDMA & rs);
    hasDMA(const hasDMA & hs);
    ~hasDMA();
    hasDMA & operator=(const hasDMA & rs);
    friend std::ostream & operator<<(std::ostream & os, const hasDMA & rs);
};

#endif

#define _CRT_SECURE_NO_WARNINGS

#include <cstring>
#include "dma.h"

baseDMA::baseDMA(const char * l, int r) {
    label = ];
    std::strcpy(label, l);
    rating = r;
}

baseDMA::baseDMA(const baseDMA & rs) {
    label = ];
    std::strcpy(label, rs.label);
    rating = rs.rating;
}

baseDMA::~baseDMA() {
    delete[] label;
}

baseDMA & baseDMA::operator=(const baseDMA & rs) {
    if (this == &rs) {
        return *this;
    }
    delete[] label;
    label = ];
    std::strcpy(label, rs.label);
    rating = rs.rating;
    return *this;
}

std::ostream & operator<<(std::ostream & os, const baseDMA & rs) {
    os << "Label: " << rs.label << std::endl;
    os << "Rating: " << rs.rating << std::endl;
    return os;
}

lacksDMA::lacksDMA(const char * c, const char * l, int r) : baseDMA(l, r) {
    std::strncpy(color, c, );
    color[] = '\0';
}

lacksDMA::lacksDMA(const char * c, const baseDMA & rs) : baseDMA(rs) {
    std::strncpy(color, c, COL_LEN - );
    color[COL_LEN - ] = '\0';
}

std::ostream & operator<<(std::ostream & os, const lacksDMA & ls) {
    os << (const baseDMA &)ls;
    os << "Color: " << ls.color << std::endl;
    return os;
}

hasDMA::hasDMA(const char * s, const char * l, int r) : baseDMA(l, r) {
    style = ];
    std::strcpy(style, s);
}

hasDMA::hasDMA(const char * s, const baseDMA & rs) : baseDMA(rs) {
    style = ];
    std::strcpy(style, s);
}

hasDMA::hasDMA(const hasDMA & hs) : baseDMA(hs) {
    style = ];
    std::strcpy(style, hs.style);
}

hasDMA::~hasDMA() {
    delete[] style;
}

hasDMA & hasDMA::operator=(const hasDMA & hs) {
    if (this == &hs) {
        return *this;
    }
    baseDMA::operator=(hs);
    delete[] style;
    style = ];
    std::strcpy(style, hs.style);
    return *this;
}

std::ostream & operator<<(std::ostream & os, const hasDMA & hs) {
    os << (const baseDMA &)hs;
    os << "Style: " << hs.style << std::endl;
    return os;
}

#include <iostream>
#include "dma.h"

int main() {
    using std::cout;
    using std::endl;

    baseDMA shirt();
    lacksDMA balloon();
    hasDMA map();
    cout << "Displaying baseDMA object:\n";
    cout << shirt << endl;
    cout << "Displaying lacksDMA object:\n";
    cout << balloon << endl;
    cout << "Displaying hasDMA object:\n";
    cout << map << endl;
    lacksDMA balloon2(balloon);
    cout << "Result of lacksDMA copy:\n";
    cout << balloon2 << endl;
    hasDMA map2;
    map2 = map;
    cout << "Resulting of hasDMA assignment:\n";
    cout << map2 << endl;

    std::cin.get();
    std::cin.get();

    ;
}

#ifndef STUDENTC_H_
#define STUDENTC_H_

#include <iostream>
#include <string>
#include <valarray>

class Student {
private:
    typedef std::valarray<double> ArrayDb;
    std::string name;
    ArrayDb scores;
    std::ostream & arr_out(std::ostream & os) const;
public:
    Student() : name("Null Student"), scores() {}
    explicit Student(const std::string & s) : name(s), scores() {}
    explicit Student(int n) : name("Nullly"), scores(n) {}
    Student(const std::string & s, int n) : name(s), scores(n) {}
    Student(const std::string & s, const ArrayDb & a) : name(s), scores(a) {}
    Student(const char * str, const double * pd, int n) : name(str), scores(pd, n) {}
    ~Student() {}
    double Average() const;
    const std::string & Name() const;
    double & operator[](int i);
    double operator[](int i) const;
    friend std::istream & operator>>(std::istream & is, Student & stu);
    friend std::istream & getline(std::istream & is, Student & stu);
    friend std::ostream & operator<<(std::ostream & os, const Student & stu);
};

#endif

#include "studentc.h"

using std::ostream;
using std::endl;
using std::istream;
using std::string;

double Student::Average() const {
    ) {
        return scores.sum() / scores.size();
    } else {
        ;
    }
}

const string & Student::Name() const {
    return name;
}

double & Student::operator[](int i) {
    return scores[i];
}

double Student::operator[](int i) const {
    return scores[i];
}

ostream & Student::arr_out(ostream & os) const {
    int i;
    int lim = scores.size();
    ) {
        ; i < lim; i++) {
            os << scores[i] << " ";
             == ) {
                os << endl;
            }
        }
         != ) {
            os << endl;
        }
    } else {
        os << " empty array ";
    }
    return os;
}

istream & operator>>(istream & is, Student & stu) {
    is >> stu.name;
    return is;
}

istream & getline(istream & is, Student & stu) {
    getline(is, stu.name);
    return is;
}

ostream & operator<<(ostream & os, const Student & stu) {
    os << "Scores for " << stu.name << ":\n";
    stu.arr_out(os);
    return os;
}

#include <iostream>
#include "studentc.h"
using std::cin;
using std::cout;
using std::endl;

void set(Student & sa, int n);
;
;

int main() {
    Student ada[pupils] = { Student(quizzes), Student(quizzes), Student(quizzes) };
    int i;
    ; i < pupils; ++i) {
        set(ada[i], quizzes);
    }
    cout << "\nStudent List:\n";
    ; i < pupils; ++i) {
        cout << ada[i].Name() << endl;
    }
    cout << "\nResults:";
    ; i < pupils; ++i) {
        cout << endl << ada[i];
        cout << "average: " << ada[i].Average() << endl;
    }
    cout << "Done.\n";

    cin.get();
    cin.get();

    ;
}

void set(Student & sa, int n) {
    cout << "Please enter the student's name: ";
    getline(cin, sa);
    cout << "Please enter " << n << " quiz scores:\n";
    ; i < n; i++) {
        cin >> sa[i];
    }
    while (cin.get() != '\n') {
        continue;
    }
}

#ifndef STUDENTC_H_
#define STUDENTC_H_

#include <iostream>
#include <valarray>
#include <string>

class Student : private std::string, private std::valarray<double> {
private:
    typedef std::valarray<double> ArrayDb;
    std::ostream & arr_out(std::ostream & os) const;
public:
    Student() : std::string("Null Student"), ArrayDb() {}
    explicit Student(const std::string & s) : std::string(s), ArrayDb() {}
    explicit Student(int n) : std::string("Nully"), ArrayDb(n) {}
    Student(const std::string & s, int n) : std::string(s), ArrayDb(n) {}
    Student(const std::string & s, const ArrayDb & a) : std::string(s), ArrayDb(a) {}
    Student(const char * str, const double * pd, int n) : std::string(str), ArrayDb(pd, n) {}
    ~Student() {}
    double Average() const;
    double & operator[](int i);
    double operator[](int i) const;
    const std::string & Name() const;
    friend std::istream & operator>>(std::istream & is, Student & stu);
    friend std::istream & getline(std::istream & is, Student & stu);
    friend std::ostream & operator<<(std::ostream & os, const Student & stu);
};

#endif

#include "studenti.h"
using std::ostream;
using std::endl;
using std::istream;
using std::string;

double Student::Average() const {
    ) {
        return ArrayDb::sum() / ArrayDb::size();
    } else {
        ;
    }
}

const string & Student::Name() const {
    return (const string &)*this;
}

double & Student::operator[](int i) {
    return ArrayDb::operator[](i);
}

double Student::operator[](int i) const {
    return ArrayDb::operator[](i);
}

ostream & Student::arr_out(ostream & os) const {
    int i;
    int lim = ArrayDb::size();
    ) {
        ; i < lim; i++) {
            os << ArrayDb::operator[](i) << " ";
             == ) {
                os << endl;
            }
        }
         != ) {
            os << endl;
        }
    } else {
        os << " empty array ";
    }
    return os;
}

istream & operator>>(istream & is, Student & stu) {
    is >> (string &)stu;
    return is;
}

istream & getline(istream & is, Student & stu) {
    getline(is, (string &)stu);
    return is;
}

ostream & operator<<(ostream & os, const Student  & stu) {
    os << "Scores for " << (const string &)stu << ":\n";
    stu.arr_out(os);
    return os;
}

#include <iostream>
#include "studenti.h"

using std::cin;
using std::cout;
using std::endl;

void set(Student & sa, int n);

;
;

int main() {
    Student ada[pupils] = { Student(quizzes), Student(quizzes), Student(quizzes) };
    int i;
    ; i < pupils; i++) {
        set(ada[i], quizzes);
    }
    cout << "\nStudent List:\n";
    ; i < pupils; ++i) {
        cout << ada[i].Name() << endl;
    }
    cout << "\nResults:";
    ; i < pupils; i++) {
        cout << endl << ada[i];
        cout << "average: " << ada[i].Average() << endl;
    }
    cout << "Done.\n";

    cin.get();
    cin.get();

    ;
}

void set(Student & sa, int n) {
    cout << "Please enter the student's name: ";
    getline(cin, sa);
    cout << "Please enter " << n << " quiz scores:\n";
    ; i < n; i++) {
        cin >> sa[i];
    }
    while (cin.get() != '\n') {
        continue;
    }
}

#ifndef WORKER0_H_
#define WORKER0_H_

#include <string>

class Worker {
private:
    std::string fullname;
    long id;
public:
    Worker() : fullname("no one"), id(0L) {}
    Worker(const std::string & s, long n) : fullname(s), id(n) {}
    ;
    virtual void Set();
    virtual void Show() const;
};

class Waiter : public Worker {
private:
    int panache;
public:
    Waiter() : Worker(), panache() {}
    Waiter() : Worker(s, n), panache(p) {}
    Waiter() : Worker(wk), panache(p) {}
    void Set();
    void Show() const;
};

class Singer : public Worker {
protected:
    enum { other, alto, contralto, soprano, bass, baritone, tenor };
     };
private:
    static char * pv[Vtypes];
    int voice;
public:
    Singer() : Worker(), voice(other) {}
    Singer(const std::string & s, long n, int v = other) : Worker(s, n), voice(v) {}
    Singer(const Worker & wk, int v = other) : Worker(wk), voice(v) {}
    void Set();
    void Show() const;
};

#endif

#include "worker0.h"
#include <iostream>
using std::cout;
using std::cin;
using std::endl;

Worker::~Worker() {}

void Worker::Set() {
    cout << "Enter worker's name: ";
    getline(cin, fullname);
    cout << "Enter worker's ID: ";
    cin >> id;
    while (cin.get() != '\n') {
        continue;
    }
}

void Worker::Show() const {
    cout << "Name: " << fullname << "\n";
    cout << "Employee ID: " << id << "\n";
}

void Waiter::Set() {
    Worker::Set();
    cout << "Enter waiter's panache rating: ";
    cin >> panache;
    while (cin.get() != '\n') {
        continue;
    }
}

void Waiter::Show() const {
    cout << "Category: waiter\n";
    Worker::Show();
    cout << "Panache rating: " << panache << "\n";
}

char * Singer::pv[] = { (char *)"other", (char *)"alto", (char *)"contralto", (char *)"soprano", (char *)"bass", (char *)"baritone", (char *)"tenor" };

void Singer::Set() {
    Worker::Set();
    cout << "Enter number of singer's vocal range:\n";
    int i;
    ; i < Vtypes; i++) {
        cout << i << ": " << pv[i] << "    ";
         == ) {
            cout << endl;
        }
    }

     != ) {
        cout << endl;
    }

     || voice >= Vtypes)) {
        cout << "Please enter a value >= 0 and  < " << Vtypes << endl;
    }

    while (cin.get() != '\n') {
        continue;
    }
}

void Singer::Show() const {
    cout << "Category: singer\n";
    Worker::Show();
    cout << "Vocal range: " << pv[voice] << endl;
}

#include <iostream>
#include "worker0.h"

;

int main() {
    Waiter bob();
    Singer bev();
    Waiter w_temp;
    Singer s_temp;

    Worker * pw[LIM] = { &bob, &bev, &w_temp, &s_temp };

    int i;
    ; i < LIM; i++) {
        pw[i]->Set();
    }
    ; i < LIM; i++) {
        pw[i]->Show();
        std::cout << std::endl;
    }

    std::cin.get();
    std::cin.get();
    ;
}

#ifndef WORKERMI_H_
#define WORKERMI_H_

#include <string>

class Worker {
private:
    std::string fullname;
    long id;
protected:
    virtual void Data() const;
    virtual void Get();
public:
    Worker() : fullname("no one"), id(0L) {}
    Worker(const std::string & s, long n) : fullname(s), id(n) {}
    ;
    ;
    ;
};

class Waiter : virtual public Worker {
private:
    int panache;
protected:
    void Data() const;
    void Get();
public:
    Waiter() : Worker(), panache() {}
    Waiter() : Worker(s, n), panache(p) { }
    Waiter() : Worker(wk), panache(p) {}
    void Set();
    void Show() const;
};

class Singer : virtual public Worker {
protected:
    enum { other, alto, contralto, soprano, bass, baritone, tenor };
     };
    void Data() const;
    void Get();
private:
    static char *pv[Vtypes];
    int voice;
public:
    Singer() : Worker(), voice(other) {}
    Singer(const std::string & s, long n, int v = other) : Worker(s, n), voice(v) {}
    void Set();
    void Show() const;
};

class SingingWaiter : public Singer, public Waiter {
protected:
    void Data() const;
    void Get();
public:
    SingingWaiter() {}
    SingingWaiter(, int v = other) : Worker(s,n), Waiter(s, n, p), Singer(s, n, v) {}
    SingingWaiter(, int v = other) : Worker(wk), Waiter(wk, p), Singer(wk, v) {}
    SingingWaiter(const Waiter & wt, int v = other) : Worker(wt), Waiter(wt), Singer(wt, v) {}
    SingingWaiter() : Worker(wt), Waiter(wt, p), Singer(wt) {}
    void Set();
    void Show() const;
};

#endif

#include "workermi.h"
#include <iostream>
using std::cout;
using std::cin;
using std::endl;

Worker::~Worker() {}

void Worker::Data() const {
    cout << "Name: " << fullname << endl;
    cout << "Employee ID: " << id << endl;
}

void Worker::Get() {
    getline(cin, fullname);
    cout << "Enter worker's ID: ";
    cin >> id;
    while (cin.get() != '\n') {
        continue;
    }
}

void Waiter::Set() {
    cout << "Enter waiter's name: ";
    Worker::Get();
    Get();
}

void Waiter::Show() const {
    cout << "Category: waiter\n";
    Worker::Data();
    Data();
}

void Waiter::Data() const {
    cout << "Panache rating: " << panache << endl;
}

void Waiter::Get() {
    cout << "Enter waiter's panache rating: ";
    cin >> panache;
    while (cin.get() != '\n') {
        continue;
    }
}

char * Singer::pv[Singer::Vtypes] = { (char *)"other", (char *)"alto", (char *)"contralto", (char *)"soprano", (char *)"bass", (char *)"baritone", (char *)"tenor" };

void Singer::Set() {
    cout << "Enter singer's name: ";
    Worker::Get();
    Get();
}

void Singer::Show() const {
    cout << "Category: singer\n";
    Worker::Data();
    Data();
}

void Singer::Data() const {
    cout << "Vocal range: " << pv[voice] << endl;
}

void Singer::Get() {
    cout << "Enter number for singer's vocal range:\n";
    int i;
    ; i < Vtypes; i++) {
        cout << i << ": " << pv[i] << "    ";
         == ) {
            cout << endl;
        }
    }
     != ) {
        cout << '\n';
    }
    cin >> voice;
    while (cin.get() != '\n') {
        continue;
    }
}

void SingingWaiter::Data() const {
    Singer::Data();
    Waiter::Data();
}

void SingingWaiter::Get() {
    Waiter::Get();
    Singer::Get();
}

void SingingWaiter::Set() {
    cout << "Enter singing waiter's name: ";
    Worker::Get();
    Get();
}

void SingingWaiter::Show() const {
    cout << "Category: singing waiter\n";
    Worker::Data();
    Data();
}

#include <iostream>
#include <cstring>
#include "workermi.h"

;

int main() {
    using std::cin;
    using std::cout;
    using std::endl;
    using std::strchr;

    Worker * lolas[SIZE];

    int ct;
    ; ct < SIZE; ct++) {
        char choice;
        cout << "Enter the employee category:\n"
            << "w: waiter s:singer "
            << "t: singing waiter q: quit\n";
        cin >> choice;
        while (strchr("wstq", choice) == NULL) {
            cout << "Please enter a w, s, t, or q: ";
            cin >> choice;
        }
        if (choice == 'q') {
            break;
        }
        switch (choice) {
        case 'w':
            lolas[ct] = new Waiter;
            break;
        case 's':
            lolas[ct] = new Singer;
            break;
        case 't':
            lolas[ct] = new SingingWaiter;
            break;
        }
        cin.get();
        lolas[ct]->Set();
    }

    cout << "\nHere is your staff:\n";
    int i;
    ; i < ct; i++) {
        cout << endl;
        lolas[i]->Show();
    }
    ; i < ct; i++) {
        delete lolas[i];
    }
    cout << "Bye.\n";

    cin.get();
    cin.get();

    ;
}

#ifndef STACKTP_H_
#define STACKTP_H_

template <class Type>
class Stack {
private:
     };
    Type items[MAX];
    int top;
public:
    Stack();
    bool isempty();
    bool isfull();
    bool push(const Type & item);
    bool pop(Type & item);
};

template <class Type>
Stack<Type>::Stack() {
    top = ;
}

template <class Type>
bool Stack<Type>::isempty() {
    ;
}

template <class Type>
bool Stack<Type>::isfull() {
    return top == MAX;
}

template <class Type>
bool Stack<Type>::push(const Type & item) {
    if (top < MAX) {
        items[top++] = item;
        return true;
    } else {
        return false;
    }
}

template <class Type>
bool Stack<Type>::pop(Type & item) {
    ) {
        item = items[--top];
        return true;
    } else {
        return false;
    }
}

#endif

#include <iostream>
#include <string>
#include <cctype>
#include "stacktp.h"
using std::cin;
using std::cout;

int main() {
    Stack<std::string> st;
    char ch;
    std::string po;
    cout << "Please enter A to add a purchase order,\n"
        << "P to process a PO, or Q to quit.\n";
    while (cin >> ch && std::toupper(ch) != 'Q') {
        while (cin.get() != '\n') {
            continue;
        }
        if (!std::isalpha(ch)) {
            cout << '\a';
            continue;
        }
        switch (ch)
        {
        case 'A':
        case 'a':
            cout << "Enter a PO number to add: ";
            cin >> po;
            if (st.isfull()) {
                cout << "stack already full\n";
            } else {
                st.push(po);
            }
            break;
        case 'P':
        case 'p':
            if (st.isempty()) {
                cout << "stack already empty\n";
            } else {
                st.pop(po);
                cout << "PO #" << po << " popped\n";
                break;
            }
        }
        cout << "Please enter A to add a purchase order,\n"
            << "P to process a PO, or Q to quit.\n";
    }

    cout << "Bye\n";
    ;
}

#ifndef STACKTP1_H_
#define STACKTP1_H_

template <class Type>
class Stack {
private:
     };
    int stacksize;
    Type * items;
    int top;
public:
    explicit Stack(int ss = SIZE);
    Stack(const Stack & st);
    ~Stack() { delete[] items; }
    bool isempty() {
        ;
    }
    bool isfull() {
        return top == stacksize;
    }
    bool push(const Type & item);
    bool pop(Type & item);
    Stack & operator=(const Stack & st);
};

template <class Type>
Stack<Type>::Stack() {
    items = new Type[stacksize];
}

template <class Type>
Stack<Type>::Stack(const Stack  & st) {
    stacksize = st.stacksize;
    top = st.top;
    items = new Type[stacksize];
    ; i < top; i++) {
        items[i] = st.items[i];
    }
}

template <class Type>
bool Stack<Type>::push(const Type & item) {
    if (top < stacksize) {
        items[top++] = item;
        return true;
    } else {
        return false;
    }
}

template <class Type>
bool Stack<Type>::pop(Type & item) {
    ) {
        item = items[--top];
        return true;
    } else {
        return false;
    }
}

template <class Type>
Stack<Type> & Stack<Type>::operator=(const Stack<Type> & st) {
    if (this == &st) {
        return *this;
    }
    delete[] items;
    stacksize = st.stacksize;
    top = st.top;
    items = new Type[stacksize];
    ; i < top; i++) {
        items[i] = st.items[i];
    }
    return *this;
}

#endif

#include <iostream>
#include <cstdlib>
#include <ctime>
#include "stcktp1.h"
;

int main() {
    std::srand(std::time());
    std::cout << "Please enter stack size: ";
    int stacksize;
    std::cin >> stacksize;
    Stack<const char *> st(stacksize);

    const char * in[Num] = {
        " 1: Hank Gilgamesh",
        " 2: Kiki Ishtar",
        " 3: Betty Rocket",
        " 4: Ian Flagranti",
        " 5: Wolfgang Kibble",
        " 6: Portia Koop",
        " 7: Joy ALmondo",
        " 8: Xaverie Paprika",
        " 9: Juan Moore",
        "10: Misha Mache"
    };

    const char * out[Num];

    ;
    ;
    while (processed < Num) {
        if (st.isempty()) {
            st.push(in[nextin++]);
        } else if (st.isfull()) {
            st.pop(out[processed++]);
        }  && nextin < Num) {
            st.push(in[nextin++]);
        } else {
            st.pop(out[processed++]);
        }
    }

    ; i < Num; i++) {
        std::cout << out[i] << std::endl;
    }

    std::cout << "Bye\n";

    std::cin.get();
    std::cin.get();

    ;
}

#ifndef ARRAYTP_H_
#define ARRAYTP_H_

#include <iostream>
#include <cstdlib>

template <class T, int n>
class ArrayTP {
private:
    T ar[n];
public:
    ArrayTP() {};
    explicit ArrayTP(const T & v);
    virtual T & operator[](int i);
    virtual T operator[](int i) const;
};

template <class T, int n>
ArrayTP<T, n>::ArrayTP(const T & v) {
    ; i < n; i++) {
        ar[i] = v;
    }
}

template <class T, int n>
T & ArrayTP<T, n>::operator[](int i) {
     || i >= n) {
        std::cerr << "Error in array limits: " << i
            << " is out of range\n";
        std::exit(EXIT_FAILURE);
    }
    return ar[i];
}

template <class T, int n>
T ArrayTP<T, n>::operator[](int i) const {
     || i >= n) {
        std::cerr << "Error in array limits: " << i
            << " is out of range\n";
        std::exit(EXIT_FAILURE);
    }
    return ar[i];
}

#endif 

#include <iostream>
#include "arraytp.h"

int main() {
    using std::cout;
    using std::endl;
    ArrayTP<> sums;
    ArrayTP<> aves;
    ArrayTP< ArrayTP<>, > twodee;

    int i, j;

    ; i < ; i++) {
        sums[i] = ;
        ; j < ; j++) {
            twodee[i][j] = (i + ) * (j + );
            sums[i] += twodee[i][j];
        }
        aves[i] = (;
    }

    ; i < ; i++) {
        ; j < ; j++) {
            cout.width();
            cout << twodee[i][j] << ' ';
        }
        cout << ": sum = ";
        cout.width();
        cout << sums[i] << ", average = " << aves[i] << endl;
    }

    cout << "Done.\n";

    std::cin.get();
    std::cin.get();

    ;
}

#include <iostream>
#include <string>

template <class T1, class T2>
class Pair {
private:
    T1 a;
    T2 b;
public:
    T1 & first();
    T2 & second();
    T1 first() const { return a; }
    T2 second() const { return b; }
    Pair(const T1 & aval, const T2 & bval) : a(aval), b(bval) { }
    Pair() {}
};

template<class T1, class T2>
T1 & Pair<T1, T2>::first() {
    return a;
}

template<class T1, class T2>
T2 & Pair<T1, T2>::second() {
    return b;
}

int main() {
    using std::cout;
    using std::endl;
    using std::string;
    Pair<] = {
        Pair<),
        Pair<),
        Pair<),
        Pair<)
    };

    int joints = sizeof(ratings) / sizeof(Pair<string, int>);
    cout << "Rating:\t Eatery\n";
    ; i < joints; i++) {
        cout << ratings[i].second() << ":\t"
            << ratings[i].first() << endl;
    }
    cout << "Oops! Revised rating:\n";
    ratings[].first() = "Bertie's Fab Eats";
    ratings[].second() = ;
    cout << ratings[].second() << ":\t "
        << ratings[].first() << endl;

    std::cin.get();
    std::cin.get();

    ;
}

#include <iostream>
using std::cout;
using std::endl;

template <typename T>
class beta {
private:
    template <typename V>
    class hold {
    private:
        V val;
    public:
        hold(V v = ) : val(v) {}
        void show() const { cout << val << endl; }
        V Value() const { return val; }
    };
    hold<T> q;
    hold<int> n;
public:
    beta(T t, int i) : q(t), n(i) {}
    template<typename U>
    U blab(U u, T t) {
        return (n.Value() + q.Value()) * u / t;
    }
    void Show() const {
        q.show();
        n.show();
    }
};

int main() {
    beta<);
    cout << "T was set to double\n";
    guy.Show();
    cout << "V was set to T, which is double, then V was set to int\n";
    cout << guy.blab(, 2.3) << endl;
    cout << "U was set to int\n";
    cout << guy.blab(10.0, 2.3) << endl;
    cout << "U was set to double\n";
    cout << "Done\n";

    std::cin.get();

    ;
}

#include <iostream>
#include "stacktp.h"

template <template <typename T> class Thing>
class Crab {
private:
    Thing<int> s1;
    Thing<double> s2;
public:
    Crab() {};
    bool push(int a, double x) {
        return s1.push(a) && s2.push(x);
    }
    bool pop(int & a, double & x) {
        return s1.pop(a) && s2.pop(x);
    }
};

int main() {
    using std::cout;
    using std::cin;
    using std::endl;

    int ni;
    double nb;
    cout << "Enter int double pairs, such as 4 3.5 (0 0 to end):\n";
     && nb > ) {
        if (!nebula.push(ni, nb)) {
            break;
        }
    }

    while (nebula.pop(ni, nb)) {
        cout << ni << ", " << nb << endl;
    }

    cout << "Done.\n";

    ;
}

#include <iostream>
using std::cout;
using std::endl;

template <typename T>
class HasFriend {
private:
    T item;
public:
    static int ct;
public:
    HasFriend(const T & i) : item(i) {
        ct++;
    }
    ~HasFriend() {
        ct--;
    }
    friend void counts();
    friend void reports(HasFriend<T> &);
};

template <typename T>
;

void counts() {
    cout << "int count: " << HasFriend<int>::ct << "; ";
    cout << "double count: " << HasFriend<double>::ct << endl;
}

void reports(HasFriend<int> & hf) {
    cout << "HasFriend<int>: " << hf.item << endl;
}

void reports(HasFriend<double> & hf) {
    cout << "HasFriend<double>: " << hf.item << endl;
}

int main() {
    cout << "No objects declared: ";
    counts();

    HasFriend<);
    cout << "After hfi1 declared: ";
    counts();

    HasFriend<);
    cout << "After hfi2 declared: ";
    counts();

    HasFriend<double> hfdb(10.5);
    cout << "After hfdb declared: ";
    counts();

    reports(hfi1);
    reports(hfi2);
    reports(hfdb);

    std::cin.get();

}

#include <iostream>
using std::cout;
using std::endl;

template <typename T> void counts();
template <typename T> void report(T &);

template <typename TT>
class HasFriendT {
private:
    TT item;
public:
    static int ct;
public:
    HasFriendT(const TT & i) : item(i) {
        ct++;
    }
    ~HasFriendT() {
        ct--;
    }
    friend void counts<TT>();
    friend void report<>(HasFriendT<TT> &);
};

template <typename T>
;

template <typename T>
void counts() {
    cout << "template size: " << sizeof(HasFriendT<T>) << "; ";
    cout << "template counts(): " << HasFriendT<T>::ct << endl;
}

template <typename T>
void report(T & hf) {
    cout << hf.item << endl;
}

int main() {
    counts<int>();
    HasFriendT<);
    HasFriendT<);
    HasFriendT<double> hfdb(10.5);
    report(hfi1);
    report(hfi2);
    report(hfdb);
    cout << "counts<int>() output:\n";
    counts<int>();
    cout << "coiunts<double>() output:\n";
    counts<double>();

    std::cin.get();

    ;
}

#include <iostream>
using std::cout;
using std::endl;

template <typename T>
class ManyFriend {
private:
    T item;
public:
    ManyFriend(const T & i) : item(i) {}
    template <typename C, typename D> friend void show2(C &, D &);
};

template <typename C, typename D> void show2(C & c, D & d) {
    cout << c.item << ", " << d.item << endl;
}

int main() {
    ManyFriend<);
    ManyFriend<);
    ManyFriend<double> hfdb(10.5);
    cout << "hfi1, hfi2: ";
    show2(hfi1, hfi2);
    cout << "hfdb, hfi2: ";
    show2(hfdb, hfi2);

    std::cin.get();

    ;
}

#ifndef TV_H_
#define TV_H_

class Tv {
public:
    friend class Remote;
    enum { Off, On };
     };
    enum { Antenna, Cable };
    enum { TV, DVD };

    Tv() : state(s), volume(), maxchannel(mc), channel(), mode(Cable), input(TV) {}
    void onoff() {
        state = (state == On) ? Off : On;
    }
    bool ison() const {
        return state == On;
    }
    bool volup();
    bool voldown();
    void chanup();
    void chandown();
    void set_mode() {
        mode = (mode == Antenna) ? Cable : Antenna;
    }
    void set_input() {
        input = (input == TV) ? DVD : TV;
    }
    void settings() const;

private:
    int state;
    int volume;
    int maxchannel;
    int channel;
    int mode;
    int input;
};

class Remote {
private:
    int mode;
public:
    Remote(int m = Tv::TV) : mode(m) {}
    bool volup(Tv & t) { return t.volup(); }
    bool volddown(Tv & t) { return t.voldown(); }
    void onoff(Tv & t) { t.onoff(); }
    void chanup(Tv & t) { t.chanup(); }
    void chandown(Tv & t) { t.chandown(); }
    void set_chan(Tv & t, int c) { t.channel = c; }
    void set_mode(Tv & t) { t.set_mode(); }
    void set_input(Tv & t) { t.set_input(); }
};

#endif

#include <iostream>
#include "tv.h"

bool Tv::volup() {
    if (volume < MaxVal) {
        volume++;
        return true;
    } else {
        return false;
    }
}

bool Tv::voldown() {
    if (volume > MinVal) {
        volume--;
        return true;
    } else {
        return false;
    }
}

void Tv::chanup() {
    if (channel < maxchannel) {
        channel++;
    } else {
        channel = ;
    }
}

void Tv::chandown() {
    ) {
        channel--;
    } else {
        channel = maxchannel;
    }
}

void Tv::settings() const {
    using std::cout;
    using std::endl;
    cout << "TV is " << (state == Off ? "Off" : "On") << endl;
    if (state == On) {
        cout << "Volume setting = " << volume << endl;
        cout << "Channel setting = " << channel << endl;
        cout << "Mode = "
            << (mode == Antenna ? "antenna" : "cable") << endl;
        cout << "Input = "
            << (input == TV ? "TV" : "DVD") << endl;
    }
}

#include <iostream>
#include "tv.h"

int main() {
    using std::cout;
    Tv s42;
    cout << "Initial settings for 42\" TV:\n";
    s42.settings();
    s42.onoff();
    s42.chanup();
    cout << "\nAdjusted settings for 42\" TV:\n";
    s42.chanup();
    cout << "\nAdjusted settings for 42\" TV:\n";
    s42.settings();

    Remote grey;
    grey.set_chan(s42, );
    grey.volup(s42);
    grey.volup(s42);
    cout << "\n42\" settings after using remote:\n";
    s42.settings();

    Tv s58(Tv::On);
    s58.set_mode();
    grey.set_chan(s58, );
    cout << "\n58\" settings:\n";
    s58.settings();

    std::cin.get();

    ;
}

#ifndef TVFM_H_
#define TVFM_H_

class Tv;    // forward declaration

class Remote {
public:
    enum State { Off, On };
     };
    enum { Antenna, Cable };
    enum { TV, DVD };
private:
    int mode;
public:
    Remote(int m = TV) : mode(m) {}
    bool volup(Tv & t);
    bool voldown(Tv & t);
    void onoff(Tv & t);
    void chanup(Tv & t);
    void chandown(Tv & t);
    void set_mode(Tv & t);
    void set_input(Tv & t);
    void set_chan(Tv & t, int c);
};

class Tv {
public:
    friend void Remote::set_chan(Tv & t, int c);
    enum State { Off, On };
     };
    enum { Antenna, Cable };
    enum { TV, DVD };

    Tv() : state(s), volume(), maxchannel(mc), channel(), mode(Cable), input(TV) {}
    void onoff() { state = (state == On) ? Off : On; }
    bool ison() const {
        return state == On;
    }
    bool volup();
    bool voldown();
    void chanup();
    void chandown();
    void set_mode() { mode = (mode == Antenna) ? Cable : Antenna; }
    void set_input() { input = (input == TV) ? DVD : TV; }
    void settings() const;
private:
    int state;
    int volume;
    int maxchannel;
    int channel;
    int mode;
    int input;
};

inline bool Remote::volup(Tv & t) {
    return t.volup();
}

inline bool Remote::voldown(Tv & t) {
    return t.voldown();
}

inline void Remote::onoff(Tv & t) {
    t.onoff();
}

inline void Remote::chanup(Tv & t) {
    t.chanup();
}

inline void Remote::chandown(Tv & t) {
    t.chandown();
}

inline void Remote::set_mode(Tv & t) {
    t.set_mode();
}

inline void Remote::set_input(Tv & t) {
    t.set_input();
}

inline void Remote::set_chan(Tv & t, int c) {
    t.channel = c;
}

#endif

#include <iostream>
#include "tvfm.h"

bool Tv::volup() {
    if (volume < MaxVal) {
        volume++;
        return true;
    } else {
        return false;
    }
}

bool Tv::voldown() {
    if (volume > MinVal) {
        volume--;
        return true;
    } else {
        return false;
    }
}

void Tv::chanup() {
    if (channel < maxchannel) {
        channel++;
    } else {
        channel = ;
    }
}

void Tv::chandown() {
    ) {
        channel--;
    } else {
        channel = maxchannel;
    }
}

void Tv::settings() const {
    using std::cout;
    using std::endl;
    cout << "TV is " << (state == Off ? "Off" : "On") << endl;
    if (state == On) {
        cout << "Volume setting = " << volume << endl;
        cout << "Channel setting = " << channel << endl;
        cout << "Mode = "
            << (mode == Antenna ? "antenna" : "cable") << endl;
        cout << "Input = "
            << (input == TV ? "TV" : "DVD") << endl;
    }
}

#include <iostream>
#include "tvfm.h"

int main() {
    using std::cout;
    Tv s42;
    cout << "Initial settings for 42\" TV:\n";
    s42.settings();
    s42.onoff();
    s42.chanup();
    cout << "\nAdjusted settings for 42\" TV:\n";
    s42.chanup();
    cout << "\nAdjusted settings for 42\" TV:\n";
    s42.settings();

    Remote grey;
    grey.set_chan(s42, );
    grey.volup(s42);
    grey.volup(s42);
    cout << "\n42\" settings after using remote:\n";
    s42.settings();

    Tv s58(Tv::On);
    s58.set_mode();
    grey.set_chan(s58, );
    cout << "\n58\" settings:\n";
    s58.settings();

    std::cin.get();

    ;
}

#ifndef QUEUETP_H_
#define QUEUETP_H_

template <class Item>
class QueueTP {
private:
     };
    class Node {
    public:
        Item item;
        Node * next;
        Node() { }
    };
    Node * front;
    Node * rear;
    int items;
    const int qsize;
    QueueTP() { }
    QueueTP & operator=(const QueueTP & q) { return *this; }
public:
    QueueTP(int qs = Q_SIZE);
    ~QueueTP();
    bool isempty() const {
        ;
    }
    bool isfull() const {
        return items == qsize;
    }
    int queuecount() const {
        return items;
    }
    bool enqueue(const Item & item);
    bool dequeue(Item & item);
};

template <class Item>
QueueTP<Item>::QueueTP(int qs) : qsize(qs) {
    front = rear = ;
    items = ;
}

template <class Item>
QueueTP<Item>::~QueueTP() {
    Node * temp;
    ) {
        temp = front;
        front = front->next;
        delete temp;
    }
}

template <class Item>
bool QueueTP<Item>::enqueue(const Item & item) {
    if (isfull()) {
        return false;
    }
    Node * add = new Node(item);
    items++;
    ) {
        front = add;
    } else {
        rear->next = add;
    }
    rear = add;
    return true;
}

template <class Item>
bool QueueTP<Item>::dequeue(Item & item) {
    ) {
        return false;
    }
    item = front->item;
    items--;
    Node * temp = front;
    front = front->next;
    delete temp;
    ) {
        rear = ;
    }
    return true;
}

#endif

#include <iostream>
#include <string>
#include "queutp.h"

int main() {
    using std::string;
    using std::cin;
    using std::cout;

    QueueTP<);
    string temp;

    while (!cs.isfull()) {
        cout << "Please enter your name. You will be "
            "served in the order of arrival.\n"
            "name: ";
        std::getline(cin, temp);
        cs.enqueue(temp);
    }
    cout << "The queue is full. Processing begins!\n";

    while (!cs.isempty()) {
        cs.dequeue(temp);
        cout << "Now processing " << temp << "...\n";
    }

    cin.get();

    ;
}

#include <iostream>
#include <cstdlib>

double hmean(double a, double b);

int main() {
    double x, y, z;

    std::cout << "Enter two numbers: ";
    while (std::cin >> x >> y) {
        z = hmean(x, y);
        std::cout << "Harmonic mean of " << x << " and " << y
            << " is " << z << std::endl;
        std::cout << "Enter next set of numbers <q to quit>: ";
    }
    std::cout << "Bye!\n";
    ;
}

double hmean(double a, double b) {
    if (a == -b) {
        std::cout << "untenable arguments to hmean()\n";
        std::abort();
    }
    return 2.0 * a * b / (a + b);
}

#include <iostream>
#include <cfloat>

bool hmean(double a, double b, double * ans);

int main() {
    double x, y, z;

    std::cout << "Enter two numbers: ";
    while (std::cin >> x >> y) {
        if (hmean(x, y, &z)) {
            std::cout << "Harmonic mean of " << x << " and " << y
                << " is " << z << std::endl;
        } else {
            std::cout << "One value should not be the negative "
                << "of the other - try again.\n";
        }

        std::cout << "Enter next set of numbers <q to quit>: ";
    }
    std::cout << "Bye!\n";
    ;
}

bool hmean(double a, double b, double * ans) {
    if (a == -b) {
        *ans = DBL_MAX;
        return false;
    } else {
        *ans = 2.0 * a * b / (a + b);
        return true;
    }
}

#include <iostream>

double hmean(double a, double b);

int main() {
    double x, y, z;

    std::cout << "Enter two numbers: ";
    while (std::cin >> x >> y) {
        try {    // start of try block
            z = hmean(x, y);
        } // end of try block
        catch (const char * s) {    // start of exception handler
            std::cout << s << std::endl;
            std::cout << "Enter a new pair of numbers: ";
            continue;
        }    // end of handler

        std::cout << "Harmonic mean of " << x << " and " << y
            << " is " << z << std::endl;
        std::cout << "Enter next set of numbers <q to quit>: ";
    }
    std::cout << "Bye!\n";

    std::cin.get();
    std::cin.get();

    ;
}

double hmean(double a, double b) {
    if (a == b) {
        throw "bad hmean() arguments: a = -b not allowed";
    }
    return 2.0 * a * b / (a + b);
}

#include <iostream>
#include <cmath>
#include "exc_mean.h"

double hmean(double a, double b);
double gmean(double a, double b);

int main() {
    using std::cout;
    using std::cin;
    using std::endl;

    double x, y, z;

    cout << "Enter two numbers: ";
    while (cin >> x >> y) {
        try {
            z = hmean(x, y);
            cout << "Harmonic mean of " << x << " and " << y
                << " is " << z << endl;
            cout << "Geometric mean of " << x << " and " << y
                << " is " << gmean(x, y) << endl;
            cout << "Enter next set of numbers <q to quit>: ";
        } catch (bad_hmean & bg) {
            bg.mesg();
            cout << "Try agian.\n";
            continue;
        } catch (bad_gmean & hg) {
            cout << hg.mesg();
            cout << "Values used: " << hg.v1 << ", "
                << hg.v2 << endl;
            cout << "Sorry, you don't get to play any more.\n";
            break;
        }
    }
    cout << "Bye!\n";

    cin.get();
    cin.get();

    ;
}

double hmean(double a, double b) {
    if (a == -b) {
        throw bad_hmean(a, b);
    }
    return 2.0 * a * b / (a + b);
}

double gmean(double a, double b) {
     || b < ) {
        throw  bad_gmean(a, b);
    }
    return std::sqrt(a * b);
}

#include <iostream>
#include <new>
#include <cstdlib>

using namespace std;

struct Big {
    ];
};

int main() {
    Big * pb;
    try {
        cout << "Trying to get a big block of memory:\n";
        pb = ];
        cout << "Got past the new request:\n";
    } catch (bad_alloc & ba) {
        cout << "Caught the exception!\n";
        cout << ba.what() << endl;
        exit(EXIT_FAILURE);
    }
    cout << "Memory successfully allocated\n";
    pb[].stuff[] = ;
    cout << pb[].stuff[] << endl;
    delete[] pb;

    std::cin.get();
    std::cin.get();

    ;
}

#include <stdexcept>
#include <string>

class Sales {
public:
     };

    class bad_index : public std::logic_error {
    private:
        int bi;
    public:
        explicit bad_index(int ix, const std::string & s = "Index error in Sales object\n");
        int bi_val() const { return bi; }
        virtual ~bad_index() throw() {}
    };

    );
    Sales(int yy, const double * gr, int n);
    virtual ~Sales() {}
    int Year() const { return year; }
    virtual double operator[](int i) const;
    virtual double & operator[](int i);
private:
    double gross[MONTHS];
    int year;
};

class LabeledSales : public Sales {
public:

    class nbad_index : public Sales::bad_index {
    private:
        std::string lbl;
    public:
        nbad_index(const std::string & lb, int ix, const std::string & s = "Index error in LabeledSales object\n");
        const std::string & label_val() const { return lbl; }
        virtual ~nbad_index() throw() {}
    };

    );
    LabeledSales(const std::string & lb, int yy, const double * gr, int n);
    virtual ~LabeledSales() {}
    const std::string & Label() const { return label; }
    virtual double operator[](int i) const;
    virtual double & operator[](int i);

private:
    std::string label;
};

#include "sales.h"
using std::string;

Sales::bad_index::bad_index(int ix, const string & s) : std::logic_error(s), bi(ix) {

}

Sales::Sales(int yy) {
    year = yy;
    ; i < MONTHS; ++i) {
        gross[i] = ;
    }
}

Sales::Sales(int yy, const double * gr, int n) {
    year = yy;
    int lim = (n < MONTHS) ? n : MONTHS;
    int i;
    ; i < lim; ++i) {
        gross[i] = gr[i];
    }
    for (; i < MONTHS; ++i) {
        gross[i] = ;
    }
}

double Sales::operator[](int i) const {
     || i >= MONTHS) {
        throw bad_index(i);
    }
    return gross[i];
}

double & Sales::operator[](int i) {
     || i >= MONTHS) {
        throw bad_index(i);
    }
    return gross[i];
}

LabeledSales::nbad_index::nbad_index(const string & lb, int ix, const string & s) : Sales::bad_index(ix, s) {
    lbl = lb;
}

LabeledSales::LabeledSales(const string & lb, int yy) : Sales(yy) {
    label = lb;
}

LabeledSales::LabeledSales(const string & lb, int yy, const double * gr, int n) : Sales(yy, gr, n) {
    label = lb;
}

double LabeledSales::operator[](int i) const {
     || i >= MONTHS) {
        throw nbad_index(Label(), i);
    }
    return Sales::operator[](i);
}

double & LabeledSales::operator[](int i) {
     || i >= MONTHS) {
        throw nbad_index(Label(), i);
    }
    return Sales::operator[](i);
}

#include <iostream>
#include "sales.h"

int main() {
    using std::cout;
    using std::cin;
    using std::endl;

    ] = {
        , , , , , ,
        , , , , ,
    };

    ] = {
        , , , , , ,
        , , , , ,
    };

    Sales sales1(, vals1, );
    LabeledSales sales2(, vals2, );

    cout << "First try block:\n";
    try {
        int i;
        cout << "Year = " << sales1.Year() << endl;
        ; i < ; ++i) {
            cout << sales1[i] << ' ';
             == ) {
                cout << endl;
            }
        }
        cout << "Year = " << sales1.Year() << endl;
        cout << "Label = " << sales2.Label() << endl;
        ; i <= ; ++i) {
            cout << sales2[i] << ' ';
             == ) {
                cout << endl;
            }
        }
        cout << "End of try block 1.\n";
    } catch (LabeledSales::nbad_index & bad) {
        cout << bad.what();
        cout << "Company: " << bad.label_val() << endl;
        cout << "bad index: " << bad.bi_val() << endl;
    } catch (Sales::bad_index & bad) {
        cout << bad.what();
        cout << "bad index: " << bad.bi_val() << endl;
    }

    cout << "\nNext try block:\n";
    try {
        sales2[] = 37.5;
        sales1[] = ;
        cout << "End of try block 2.\n";
    } catch (LabeledSales::nbad_index & bad) {
        cout << bad.what();
        cout << "Company: " << bad.label_val() << endl;
        cout << "bad index: " << bad.bi_val() << endl;
    } catch (Sales::bad_index & bad) {
        cout << bad.what();
        cout << "bad index: " << bad.bi_val() << endl;
    }
    cout << "done\n";

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <cstdlib>
#include <ctime>

using std::cout;

class Grand {
private:
    int hold;
public:
    Grand() : hold(h) {}
    virtual void Speak() const {
        cout << "I am a grand class!\n";
    }
    virtual int Value() const {
        return hold;
    }
};

class Superb : public Grand {
public:
    Superb() : Grand(h) {}
    void Speak() const {
        cout << "I am a superb class!!\n";
    }
    virtual void Say() const {
        cout << "I hold the superb value of " << Value() << "!\n";
    }
};

class Magnificent : public Superb {
private:
    char ch;
public:
    Magnificent(, char c = 'A') : Superb(h), ch(c) {}
    void Speak() const {
        cout << "I am a magnificent class!!\n";
    }
    void Say() const {
        cout << "I hold the characters " << ch <<
            " and the integer " << Value() << "!\n";
    }
};

Grand * GetOne();

int main() {
    std::srand(std::time());
    Grand * pg;
    Superb * ps;
    ; i < ; i++) {
        pg = GetOne();
        pg->Speak();
        if (ps = dynamic_cast<Superb *>(pg)) {
            ps->Say();
        }
    }

    std::cin.get();

    ;
}

Grand * GetOne() {
    Grand * p = nullptr;
    ) {
    :
        p = );
        break;
    :
        p = );
        break;
    :
        p = , );
        break;
    }

    return p;
}

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <typeinfo>

using namespace std;

class Grand {
private:
    int hold;
public:
    Grand() : hold(h) {}
    virtual void Speak() const {
        cout << "I am a grand class!\n";
    }
    virtual int Value() const {
        return hold;
    }
};

class Superb : public Grand {
public:
    Superb() : Grand(h) {}
    void Speak() const {
        cout << "I am a superb class!!\n";
    }
    virtual void Say() const {
        cout << "I hold the superb value of " << Value() << "!\n";
    }
};

class Magnificent : public Superb {
private:
    char ch;
public:
    Magnificent(, char c = 'A') : Superb(h), ch(c) {}
    void Speak() const {
        cout << "I am a magnificent class!!\n";
    }
    void Say() const {
        cout << "I hold the characters " << ch <<
            " and the integer " << Value() << "!\n";
    }
};

Grand * GetOne();

int main() {
    srand(time());
    Grand * pg;
    Superb * ps;
    ; i < ; i++) {
        pg = GetOne();

        cout << "Now processing type " << typeid(*pg).name() << ".\n";
        pg->Speak();

        if (ps = dynamic_cast<Superb *>(pg)) {
            ps->Say();
        }
        if (typeid(Magnificent) == typeid(*pg)) {
            cout << "Yes, you're really magnificent.\n";
        }
    }

    std::cin.get();

    ;
}

Grand * GetOne() {
    Grand * p = nullptr;
    ) {
    :
        p = );
        break;
    :
        p = );
        break;
    :
        p = , );
        break;
    }

    return p;
}

#include <iostream>

using std::cout;
using std::endl;

void change(const int * pt, int n);

int main() {
    ;
    ;

    cout << "pop1, pop2: " << pop1 << ", " << pop2 << endl;

    change(&pop1, -);
    change(&pop2, -);

    cout << "pop1, pop2: " << pop1 << ", " << pop2 << endl;

    std::cin.get();

    ;
}

void change(const int * pt, int n) {
    int * pc;
    pc = const_cast<int *>(pt);
    *pc += n;
}

#include <iostream>
#include <string>

int main() {
    using namespace std;

    string one("Lottery Winner!");
    cout << one << endl;

    , '$');
    cout << two << endl;

    string three(one);
    cout << three << endl;

    one += " Oops!";
    cout << one << endl;

    two = "Sorry! That was ";
    three[] = 'P';

    string four;
    four = two + three;

    char alls[] = "All's well that ends well";
    );
    cout << five << "!\n";

    , alls + );
    cout << six << ", ";

    ], &five[]);
    cout << seven << "...\n";

    , );
    cout << eight << " in motion!" << endl;

    std::cin.get();

    ;
}

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>

int main() {
    using namespace std;
    ifstream fin;
    fin.open("tobuy.txt");

    if (fin.is_open() == false) {
        cerr << "Can't open file. Bye.\n";
        exit(EXIT_FAILURE);
    }
    string item;
    ;
    getline(fin, item, ':');
    while (fin) {
        ++count;
        cout << count << ": " << item << endl;
        getline(fin, item, ':');
    }

    cout << "Done\n";
    fin.close();

    ;
}

#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>
#include <cctype>

using std::string;

;
const string wordlist[NUM] = {
    "apiary", "beetle", "cereal", "danger", "ensign", "florid", "garage", "health", "insult",
    "jackal", "keeper", "loaner", "manage", "nonce", "onset", "plaid", "quilt", "remote", "stolid",
    "train", "useful", "valid", "whence", "xenon", "yearn", "zippy"
};

int main() {
    using std::cout;
    using std::cin;
    using std::tolower;
    using std::endl;
    std::srand(std::time());
    char play;
    cout << "Will you play a word game? <y/n> ";
    cin >> play;
    play = tolower(play);

    while (play == 'y') {
        string target = wordlist[std::rand() % NUM];
        int length = target.length();
        string attempt(length, '-');
        string badchars;
        ;
        cout << "Guess my secret word. It has " << length
            << " letters, and you guess\n"
            << "one letter at a time. You get " << guesses
            << " wrong guesses.\n";
        cout << "Your word: " << attempt << endl;

         && attempt != target) {
            char letter;
            cout << "Guess a letter: ";
            cin >> letter;
            if (badchars.find(letter) != string::npos || attempt.find(letter) != string::npos) {
                cout << "You already guessed that. Try again.\n";
                continue;
            }
            int loc = target.find(letter);
            if (loc == string::npos) {
                cout << "Oh, bad guess!\n";
                --guesses;
                badchars += letter;
            } else {
                cout << "Good guess!\n";
                attempt[loc] = letter;
                loc = target.find(letter, loc + );
                while (loc != string::npos) {
                    attempt[loc] = letter;
                    loc = target.find(letter, loc + );
                }
            }
            cout << "Your word: " << attempt << endl;
            if (attempt != target) {
                ) {
                    cout << "Bad choices: " << badchars << endl;
                }
                cout << guesses << " bad guesses left\n";
            }
        }

        ) {
            cout << "That's  right!\n";
        } else {
            cout << "Sorry, the word is " << target << ".\n";
            cout << "Will you play another? <y/n> ";
            cin >> play;
            play = tolower(play);
        }

        cout << "Bye\n";

        cin.get();
        cin.get();

        ;
    }

}

#include <iostream>
#include <string>

int main() {
    using namespace std;
    string empty;
    string small = "bit";
    string larger = "Elephants are a girl's best friend";
    cout << "Sizes:\n";
    cout << "\tempty: " << empty.size() << endl;
    cout << "\tsmall: " << small.size() << endl;
    cout << "\tlarger: " << larger.size() << endl;
    cout << "Capacities:\n";
    cout << "\tempty: " << empty.capacity() << endl;
    cout << "\tsmall: " << small.capacity() << endl;
    cout << "\tlarger: " << larger.capacity() << endl;
    empty.reserve();
    cout << "Capacity after empty.reserve(50): "
        << empty.capacity() << endl;

    cin.get();

    ;
}

#include <iostream>
#include <string>
#include <memory>

class Report {
private:
    std::string str;
public:
    Report(const std::string s) : str(s) {
        std::cout << "Object created!\n";
    }
    ~Report() {
        std::cout << "Object deleted!\n";
    }
    void comment() const {
        std::cout << str << "\n";
    }
};

int main() {
    {
        std::auto_ptr<Report> ps(new Report("using auto_ptr"));
        ps->comment();
    }
    {
        std::shared_ptr<Report> ps(new Report("using shared_ptr"));
        ps->comment();
    }
    {
        std::unique_ptr<Report> ps(new Report("using unique_ptr"));
        ps->comment();
    }

    std::cin.get();
    std::cin.get();

    ;
}

#include <iostream>
#include <string>
#include <memory>

int main() {
    using namespace std;
    auto_ptr<] = {
        auto_ptr<string>(new string("Fowl Balls")),
        auto_ptr<string>(new string("Duck Walks")),
        auto_ptr<string>(new string("Chicken Runs")),
        auto_ptr<string>(new string("Turkey Errors")),
        auto_ptr<string>(new string("Goose Eggs"))
    };
    auto_ptr<string> pwin;
    pwin = films[];

    cout << "The nominees for best avian baseball film are\n";
    ; i < ; i++) {
        cout << *films[i] << endl;
    }
    cout << "The winner is " << *pwin << "!\n";

    cin.get();

    ;
}

#include <iostream>
#include <string>
#include <memory>

int main() {
    using namespace std;
    shared_ptr<] = {
        shared_ptr<string>(new string("Fowl Balls")),
        shared_ptr<string>(new string("Duck Walks")),
        shared_ptr<string>(new string("Chicken Runs")),
        shared_ptr<string>(new string("Turkey Errors")),
        shared_ptr<string>(new string("Goose Eggs"))
    };
    shared_ptr<string> pwin;
    pwin = films[];

    cout << "The nominees for best avian baseball film are\n";
    ; i < ; i++) {
        cout << *films[i] << endl;
    }
    cout << "The winner is " << *pwin << "!\n";

    cin.get();

    ;
}

#include <iostream>
#include <string>
#include <memory>

int main() {
    using namespace std;
    unique_ptr<] = {
        unique_ptr<string>(new string("Fowl Balls")),
        unique_ptr<string>(new string("Duck Walks")),
        unique_ptr<string>(new string("Chicken Runs")),
        unique_ptr<string>(new string("Turkey Errors")),
        unique_ptr<string>(new string("Goose Eggs"))
    };
    unique_ptr<string> pwin;
    pwin = films[];

    cout << "The nominees for best avian baseball film are\n";
    ; i < ; i++) {
        cout << *films[i] << endl;
    }
    cout << "The winner is " << *pwin << "!\n";

    cin.get();

    ;
}

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

;

int main() {
    using std::vector;
    using std::string;
    using std::cin;
    using std::cout;
    using std::endl;

    vector<int> ratings(NUM);
    vector<string> titles(NUM);
    cout << "You will do exactly as told. You will enter\n"
        << NUM << " book titles and your ratings (0-10).\n";
    int i;
    ; i < NUM; i++) {
        cout <<  << ": ";
        getline(cin, titles[i]);
        cout << "Enter your rating (0-10): ";
        cin >> ratings[i];
        cin.get();
    }

    cout << "Thank you. You entered the following:\n"
        << "Rating\tBook\n";
    ; i < NUM; i++) {
        cout << ratings[i] << "\t" << titles[i] << endl;
    }

    cin.get();

    ;
}

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

struct Review {
    std::string title;
    int rating;
};

bool operator<(const Review & r1, const Review & r2);
bool worseThan(const Review & r1, const Review & r2);
bool FillReview(Review & rr);
void ShowReview(const Review & rr);

int main() {
    using namespace std;

    vector<Review> books;
    Review temp;
    while (FillReview(temp)) {
        books.push_back(temp);
    }
    ) {
        cout << "Thank you. You entered the following "
            << books.size() << " ratings:\n"
            << "Rating\tBook\n";
        for_each(books.begin(), books.end(), ShowReview);

        sort(books.begin(), books.end());
        cout << "Sorted by title:\nRating\tBook\n";
        for_each(books.begin(), books.end(), ShowReview);

        sort(books.begin(), books.end(), worseThan);
        cout << "Sorted by rating:\nRating\tBook\n";
        for_each(books.begin(), books.end(), ShowReview);

        random_shuffle(books.begin(), books.end());
        cout << "After shuffling:\nRating\tBook\n";
        for_each(books.begin(), books.end(), ShowReview);

    } else {
        cout << "No entries. ";
        cout << "Bye.\n";
    }

    cin.get();
    cin.get();

    ;
}

bool operator<(const Review & r1, const Review & r2) {
    if (r1.title < r2.title) {
        return true;
    } else if (r1.title == r2.title && r1.rating < r2.rating) {
        return true;
    } else {
        return false;
    }
}

bool worseThan(const Review & r1, const Review & r2) {
    if (r1.rating < r2.rating) {
        return true;
    } else {
        return false;
    }
}

bool FillReview(Review & rr) {
    std::cout << "Enter book title (quit to quit): ";
    std::getline(std::cin, rr.title);
    if (rr.title == "quit") {
        return false;
    }
    std::cout << "Enter book rating: ";
    std::cin >> rr.rating;
    if (!std::cin) {
        return false;
    }
    while (std::cin.get() != '\n') {
        continue;
    }
    return true;
}

void ShowReview(const Review & rr) {
    std::cout << rr.rating << "\t" << rr.title << std::endl;
}

#include <iostream>
#include <iterator>
#include <vector>

int main() {
    using namespace std;

    ] = { , , , , , , , , ,  };
    vector<);

    copy(casts, casts + , dice.begin());
    cout << "Let the dice be cast!\n";

    ostream_iterator<int, char> out_iter(cout, " ");
    copy(dice.begin(), dice.end(), out_iter);
    cout << endl;

    cout << "Implicit use of reverse iterator.\n";
    copy(dice.rbegin(), dice.rend(), out_iter);
    cout << endl;

    cout << "Explicit use of reverse iterator.\n";
    vector<int>::reverse_iterator ri;
    for (ri = dice.rbegin(); ri != dice.rend(); ++ri) {
        cout << *ri << ' ';
    }
    cout << endl;

    cin.get();

    ;
}

#include <iostream>
#include <string>
#include <iterator>
#include <vector>
#include <algorithm>

void output(const std::string & s) {
    std::cout << s << " ";
}

int main() {
    using namespace std;

    ] = { "fine", "fish", "fashion", "fate" };
    ] = { "busy", "bats" };
    ] = { "silly", "singers" };

    vector<);
    copy(s1, s1 + , words.begin());
    for_each(words.begin(), words.end(), output);
    cout << endl;

    copy(s2, s2 + , back_insert_iterator<vector<string> >(words));
    for_each(words.begin(), words.end(), output);
    cout << endl;

    copy(s3, s3 + , insert_iterator<vector<string> >(words, words.begin()));
    for_each(words.begin(), words.end(), output);
    cout << endl;

    cin.get();

    ;
}

#include <iostream>
#include <list>
#include <iterator>
#include <algorithm>

void outint(int n) {
    std::cout << n << " ";
}

int main() {
    using namespace std;

    list<, );

    ] = { , , , ,  };

    list<int> two;
    two.insert(two.begin(), stuff, stuff + );

    ] = { , , , , ,  };

    list<int> three(two);
    three.insert(three.end(), more, more + );

    cout << "List one: ";
    for_each(one.begin(), one.end(), outint);

    cout << endl << "List two: ";
    for_each(two.begin(), two.end(), outint);

    cout << endl << "List three: ";
    for_each(three.begin(), three.end(), outint);

    three.remove();
    cout << endl << "List three minus 2s: ";
    for_each(three.begin(), three.end(), outint);

    three.splice(three.begin(), one);
    cout << endl << "List three after splice: ";
    for_each(three.begin(), three.end(), outint);

    cout << endl << "List one: ";
    for_each(one.begin(), one.end(), outint);

    three.unique();
    cout << endl << "List three after unique: ";
    for_each(three.begin(), three.end(), outint);

    three.sort();
    three.unique();
    cout << endl << "List three after sort & unique: ";
    for_each(three.begin(), three.end(), outint);

    two.sort();
    cout << endl << "Sorted two merged into three: ";
    for_each(three.begin(), three.end(), outint);
    cout << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <string>
#include <set>
#include <algorithm>
#include <iterator>

int main() {
    using namespace std;

    ;
    string s1[N] = { "buffoon", "thinkers", "for", "heavy", "can", "for" };
    string s2[N] = { "metal", "any", "food", "elegant", "deliver", "for" };

    set<string> A(s1, s1 + N);
    set<string> B(s2, s2 + N);

    ostream_iterator<string, char> out(cout, " ");
    cout << "Set A: ";
    copy(A.begin(), A.end(), out);
    cout << endl;

    cout << "Set B: ";
    copy(B.begin(), B.end(), out);
    cout << endl;

    cout << "Union of A and B:\n";
    set_union(A.begin(), A.end(), B.begin(), B.end(), out);
    cout << endl;

    cout << "Intersection of A and B:\n";
    set_intersection(A.begin(), A.end(), B.begin(), B.end(), out);
    cout << endl;

    cout << "Difference of A and B:\n";
    set_difference(A.begin(), A.end(), B.begin(), B.end(), out);
    cout << endl;

    set<string> C;
    cout << "Set C:\n";
    set_union(A.begin(), A.end(), B.begin(), B.end(), insert_iterator<set<string> >(C, C.begin()));
    copy(C.begin(), C.end(), out);
    cout << endl;

    string s3("grungy");
    C.insert(s3);
    cout << "Set C after insertion:\n";
    copy(C.begin(), C.end(), out);
    cout << endl;

    cout << "Showing a range:\n";
    copy(C.lower_bound("ghost"), C.upper_bound("spook"), out);
    cout << endl;

    cin.get();
    ;
}

#include <iostream>
#include <string>
#include <map>
#include <algorithm>

typedef int KeyType;
typedef std::pair<const KeyType, std::string> Pair;
typedef std::multimap<KeyType, std::string> MapCode;

int main() {
    using namespace std;

    MapCode codes;

    codes.insert(Pair(, "San Francisco"));
    codes.insert(Pair(, "Oakland"));
    codes.insert(Pair(, "*lyn"));
    codes.insert(Pair(, "Staten Island"));
    codes.insert(Pair(, "San Rafael"));
    codes.insert(Pair(, "Berkeley"));

    cout << "Number of cities with area code 415: "
        << codes.count() << endl;
    cout << "Number of cities with area code 718: "
        << codes.count() << endl;
    cout << "Number of cities with area code 510: "
        << codes.count() << endl;
    cout << "Area Code City\n";

    MapCode::iterator it;

    for (it = codes.begin(); it != codes.end(); ++it) {
        cout << "    " << (*it).first << "    "
            << (*it).second << endl;
    }
    pair<MapCode::iterator, MapCode::iterator> range = codes.equal_range();
    cout << "Cities with area code 718:\n";
    for (it = range.first; it != range.second; ++it) {
        cout << (*it).second << endl;
    }

    cin.get();

    ;
}

#include <iostream>
#include <list>
#include <iterator>
#include <algorithm>

template <class T>
class TooBig {
private:
    T cutoff;
public:
    TooBig(const T & t) : cutoff(t) { }
    bool operator()(const T & v) {
        return v > cutoff;
    }
};

void outint(int n) {
    std::cout << n << " ";
}

int main() {
    using std::list;
    using std::cout;
    using std::endl;

    TooBig<);
    ] = { , , , , , , , , ,  };
    list<);
    list<);

    cout << "Original lists:\n";
    std::for_each(yadayada.begin(), yadayada.end(), outint);
    cout << endl;
    std::for_each(etcetera.begin(), etcetera.end(), outint);
    cout << endl;

    yadayada.remove_if(f100);
    etcetera.remove_if(TooBig<));
    cout << "Trimmed lists:\n";
    std::for_each(yadayada.begin(), yadayada.end(), outint);
    cout << endl;
    std::for_each(etcetera.begin(), etcetera.end(), outint);
    cout << endl;

    std::cin.get();

    ;
}

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <functional>

void Show(double);
;

int main() {
    using namespace std;
    , , , , ,  };
    , , , , ,  };

    vector<double> gr8(arr1, arr1 + LIM);
    vector<double> m8(arr2, arr2 + LIM);

    cout.setf(ios_base::fixed);
    cout.precision();

    cout << "gr8:\t";
    for_each(gr8.begin(), gr8.end(), Show);
    cout << endl;

    cout << "m8: \t";
    for_each(m8.begin(), m8.end(), Show);
    cout << endl;

    vector<double> sum(LIM);
    transform(gr8.begin(), gr8.end(), m8.begin(), sum.begin(), plus<double>());
    cout << "sum:\t";
    for_each(sum.begin(), sum.end(), Show);
    cout << endl;

    vector<double> prod(LIM);
    transform(gr8.begin(), gr8.end(), prod.begin(), bind1st(multiplies<double>(), 2.5));
    cout << "prod:\t";
    for_each(prod.begin(), prod.end(), Show);
    cout << endl;

    cin.get();

    ;
}

void Show(double v) {
    std::cout.width();
    std::cout << v << ' ';
}

#include <iostream>
#include <string>
#include <algorithm>

int main() {
    using namespace std;

    string letters;
    cout << "Enter the letter grouping (quit to quit): ";

    while (cin >> letters && letters != "quit") {
        cout << "Permutations of " << letters << endl;
        sort(letters.begin(), letters.end());
        cout << letters << endl;
        while (next_permutation(letters.begin(), letters.end())) {
            cout << letters << endl;
        }
        cout << "Enter next sequence (quit to quit): ";
    }
    cout << "Done.\n";

    cin.get();

    ;
}

#include <iostream>
#include <list>
#include <algorithm>

void Show(int);

;

int main() {
    using namespace std;

    , , , , , , , , ,  };
    list<int> la(ar, ar + LIM);
    list<int> lb(la);

    cout << "Original list contents:\n\t";
    for_each(la.begin(), la.end(), Show);
    cout << endl;

    la.remove();
    cout << "After using the remove() method:\n";
    cout << "la:\t";
    for_each(la.begin(), la.end(), Show);
    cout << endl;

    list<int>::iterator last;
    last = remove(lb.begin(), lb.end(), );
    cout << "After using the remove() function:\n";
    cout << "lb:\t";
    for_each(lb.begin(), lb.end(), Show);
    cout << endl;

    lb.erase(last, lb.end());
    cout << "After using the erase() method:\n";
    cout << "lb:\t";
    for_each(lb.begin(), lb.end(), Show);
    cout << endl;

    cin.get();

    ;
}

void Show(int v) {
    std::cout << v << ' ';
}

#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <iterator>
#include <algorithm>
#include <cctype>

using namespace std;

char toLower(char ch) {
    return tolower(ch);
}
string & ToLower(string & st);
void display(const string & s);

int main() {
    vector<string> words;
    cout << "Enter words (enter quit to quit):\n";
    string input;
    while (cin >> input && input != "quit") {
        words.push_back(input);
    }

    cout << "You entered the following  words:\n";
    for_each(words.begin(), words.end(), display);
    cout << endl;

    set<string> wordset;
    transform(words.begin(), words.end(), insert_iterator<set<string> >(wordset, wordset.begin()), ToLower);
    cout << "\nAlphabetic list of words:\n";
    for_each(wordset.begin(), wordset.end(), display);
    cout << endl;

    map<string, int> wordmap;
    set<string>::iterator si;
    for (si = wordset.begin(); si != wordset.end(); si++) {
        wordmap[*si] = count(words.begin(), words.end(), *si);
    }

    cout << "\nWord frequency:\n";
    for (si = wordset.begin(); si != wordset.end(); si++) {
        cout << *si << ": " << wordmap[*si] << endl;
    }

    cin.get();
    cin.get();

    ;
}

string & ToLower(string & st) {
    transform(st.begin(), st.end(), st.begin(), toLower);
    return st;
}

void display(const string & s) {
    cout << s << " ";
}

#include <iostream>
#include <valarray>
#include <vector>
#include <algorithm>

int main() {
    using namespace std;
    vector<double> data;
    double temp;

    cout << "Enter numbers (<=0 to quit):\n";
    ) {
        data.push_back(temp);
    }
    sort(data.begin(), data.end());
    int size = data.size();
    valarray<double> numbers(size);
    int i;
    ; i < size; i++) {
        numbers[i] = data[i];
    }

    valarray<double> sq_rts(size);
    sq_rts = sqrt(numbers);
    valarray<double> results(size);
    results = numbers + 2.0 * sq_rts;
    cout.setf(ios_base::fixed);
    cout.precision();
    ; i < size; i++) {
        cout.width();
        cout << numbers[i] << ": ";
        cout.width();
        cout << results[i] << endl;
    }
    cout << "done\n";

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <valarray>
#include <cstdlib>

;
typedef std::valarray<int> vint;
void show(const vint & v, int clos);

int main() {
    using std::slice;
    using std::cout;
    vint valint(SIZE);

    int i;
    ; i < SIZE; ++i) {
        valint[i] = std::rand() % ;
    }
    cout << "Original array:\n";
    show(valint, );
    vint vcol(valint[slice(, , )]);
    cout << "Second column:\n";
    show(vcol, );
    vint vrow(valint[slice(, , )]);
    cout << "Second row:\n";
    show(vrow, );
    valint[slice(, , )] = ;
    cout << "Set last column to 10:\n";
    show(valint, );
    cout << "Set first column to sum of next two:\n";
    valint[slice(, , )] = vint(valint[slice(, , )]) + vint(valint[slice(, , )]);
    show(valint, );

    std::cin.get();
    std::cin.get();

    ;
}

void show(const vint & v, int cols) {
    using std::cout;
    using std::endl;

    int lim = v.size();
    ; i < lim; ++i) {
        cout.width();
        cout << v[i];

        ) {
            cout << endl;
        } else {
            cout << ' ';
        }
        ) {
            cout << endl;
        }
    }
}

#include <iostream>
#include <initializer_list>

double sum(std::initializer_list<double> il);
double average(const std::initializer_list<double> & ril);

int main() {
    using std::cout;

    cout << , ,  })
        << , ,  }) << '\n';
    std::initializer_list<double> dl = { 1.1, 2.2, 3.3, 4.4, 5.5 };
    cout << "List 2: sum = " << sum(dl)
        << ", ave = " << average(dl) << '\n';
    dl = { 16.0, 25.0, 36.0, 40.0, 64.0 };
    cout << "List 3: sum = " << sum(dl)
        << ", ave = " << average(dl) << '\n';

    std::cin.get();

    ;
}

double sum(std::initializer_list<double> il) {
    ;
    for (auto p = il.begin(); p != il.end(); p++) {
        tot += *p;
    }
    return tot;
}

double average(const std::initializer_list<double> & ril) {
    ;
    int n = ril.size();
    double ave = 0.0;
    ) {
        for (auto p = ril.begin(); p != ril.end(); p++) {
            tot += *p;
        }
        ave = tot / n;
    }
    return ave;
}

#include <iostream>
#include <cstring>

int main() {
    using std::cout;
    using std::endl;

    const char * state1 = "Florida";
    const char * state2 = "Kansas";
    const char * state3 = "Euphoria";

    int len = std::strlen(state2);
    cout << "Increasing loop index:\n";
    int i;
    ; i <= len; i++) {
        cout.write(state2, i);
        cout << endl;
    }

    cout << "Decreasing loop index:\n";
    ; i--) {
        cout.write(state2, i) << endl;
    }

    cout << "Exceeding string lengt:\n";
    cout.write(state2, len + ) << endl;

    std::cin.get();

    ;
}

#include <iostream>

int main() {
    using std::cout;

    cout << "12345678901234567890\n";

    char ch = 'K';
    ;
    cout << ch << ":\n";
    cout << t << ":\n";
    cout << -t << ":\n";

    double f1 = 1.200;
    cout << f1 << ":\n";
    cout << (f1 + 1.0 / 9.0) << ":\n";

    double f2 = 1.67E2;
    cout << f2 << ":\n";
    f2 += 1.0 / 9.0;
    cout << f2 << ":\n";
    cout << (f2 * 1.0e4) << ":\n";

    double f3 = 2.3e-4;
    cout << f3 << ":\n";
    cout << f3 /  << ":\n";

    std::cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;

    cout << "Enter an integer: ";
    int n;
    cin >> n;

    cout << "n    n * n\n";
    cout << n << "    " << n * n << " (decimal)\n";

    cout << hex;
    cout << n << "    ";
    cout << n * n << " (hexadecimal)\n";

    cout << oct << n << "    " << n * n << " (octal)\n";

    dec(cout);
    cout << n << "    " << n * n << " (decimal)\n";

    std::cin.get();
    std::cin.get();

    ;
}

#include <iostream>

int main() {
    using std::cout;

    );
    cout << "default field width = " << w << ":\n";
    cout.width();
    cout << "N" << ':';
    cout.width();
    cout << "N * N" << ":\n";

    ; i <= ; i *= ) {
        cout.width();
        cout << i << ':';
        cout.width();
        cout << i * i << ":\n";
    }

    std::cin.get();

    ;
}

#include <iostream>

int main() {
    using std::cout;
    cout.fill('*');
    ] = { "Waldo Whipsnade", "Wilmarie Wooper" };
    ] = { ,  };

    ; i < ; i++) {
        cout << staff[i] << ": $";
        cout.width();
        cout << bonus[i] << "\n";
    }

    std::cin.get();

    ;
}

#include <iostream>

int main() {
    using std::cout;

    float price1 = 20.40;
    float price2 = 1.9 + 8.0 / 9.0;

    cout << "\"Furry Friends\" is $" << price1 << "!\n";
    cout << "\"Fiery Friends\" is $" << price2 << "!\n";

    cout.precision();
    cout << "\"Furry Friends\" is $" << price1 << "!\n";
    cout << "\"Fiery Friends\" is $" << price2 << "!\n";

    std::cin.get();

    ;
}

#include <iostream>

int main() {
    using std::cout;
    using std::ios_base;

    float price1 = 20.40;
    float price2 = 1.9 + 8.0 / 9.0;

    cout.setf(ios_base::showpoint);
    cout << "\"Furry Friends\" is $" << price1 << "!\n";
    cout << "\"Fiery Friends\" is $" << price2 << "!\n";

    cout.precision();
    cout << "\"Furry Friends\" is $" << price1 << "!\n";
    cout << "\"Fiery Friends\" is $" << price2 << "!\n";

    std::cin.get();

    ;
}

#include <iostream>

int main() {
    using std::cout;
    using std::endl;
    using std::ios_base;

    ;
    cout << "Today's water temperature: ";
    cout.setf(ios_base::showpos);
    cout << temperature << endl;

    cout << "For our programming friends, that's\n";
    cout << std::hex << temperature << endl;
    cout.setf(ios_base::uppercase);
    cout.setf(ios_base::showbase);
    cout << "or\n";
    cout << temperature << endl;
    cout << "How " << true << "!  oops -- How ";
    cout.setf(ios_base::boolalpha);
    cout << true << "!\n";

    std::cin.get();

    ;
}

#include <iostream>
#include <cmath>

int main() {
    using namespace std;

    cout.setf(ios_base::left, ios_base::adjustfield);
    cout.setf(ios_base::showpos);
    cout.setf(ios_base::showpoint);
    cout.precision();

    ios::fmtflags old = cout.setf(ios_base::scientific, ios_base::floatfield);
    cout << "Left Justification:\n";
    long n;
    ; n <= ; n += ) {
        cout.width();
        cout << n << "|";
        cout.width();
        cout << sqrt(double(n)) << "|\n";
    }

    cout.setf(ios_base::internal, ios_base::adjustfield);
    cout.setf(old, ios_base::floatfield);

    cout << "Internal Justification:\n";
    ; n <= ; n += ) {
        cout.width();
        cout << n << "|";
        cout.width();
        cout << sqrt(double(n)) << "|\n";
    }

    cout.setf(ios_base::right, ios_base::adjustfield);
    cout.setf(ios_base::fixed, ios_base::floatfield);
    cout << "Right Justification:\n";
    ; n <= ; n += ) {
        cout.width();
        cout << n << "|";
        cout.width();
        cout << sqrt(double(n)) << "|\n";
    }

    std::cin.get();
    ;
}

#include <iostream>
#include <iomanip>
#include <cmath>

int main() {
    using namespace std;
    cout << fixed << right;

    cout << setw() << ) << "square root"
        << setw() << "fourth root\n";
    double root;
    ; n <= ; n += ) {
        root = sqrt(double(n));
        cout << setw() << setfill('.') << n << setfill(' ')
            << setw() << setprecision() << root
            << setw() << setprecision() << sqrt(root)
            << endl;
    }

    cin.get();

    ;
}

#include <iostream>

int main() {
    using namespace std;
    cout << "Enter numbers: ";

    ;
    int input;
    while (cin >> input) {
        sum += input;
    }

    cout << "Last value entered = " << input << endl;
    cout << "Sum = " << sum << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>

int main() {
    using std::cout;
    using std::cin;
    using std::endl;

    char ch;

    while (cin.get(ch)) {
        if (ch != '#') {
            cout << ch;
        } else {
            cin.putback(ch);
            break;
        }
    }

    if (!cin.eof()) {
        cin.get(ch);
        cout << endl << ch << " is next input character.\n";
    } else {
        cout << "End of file reached.\n";
        std::exit();
    }

    while (cin.peek() != '#') {
        cin.get(ch);
        cout << ch;
    }

    if (!cin.eof()) {
        cin.get(ch);
        cout << endl << ch << " is next input character.\n";
    } else {
        cout << "End of file reached.\n";
    }

    ;
}

#include <iostream>

;
inline void eatline() {
    while (std::cin.get() != '\n') {
        continue;
    }
}

int main() {
    using std::cin;
    using std::cout;
    using std::endl;

    char name[SLEN];
    char title[SLEN];
    cout << "Enter your name: ";
    cin.get(name, SLEN);
    if (cin.peek() != '\n') {
        cout << "Sorry, we only have enough room for "
            << name << endl;
    }
    eatline();
    cout << "Dear " << name << ", enter your title: \n";
    cin.get(title, SLEN);
    if (cin.peek() != '\n') {
        cout << "We were forced to turncate your title.\n";
    }
    eatline();
    cout << " Name: " << name
        << "\nTitle: " << title << endl;

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <fstream>
#include <string>

int main() {
    using namespace std;
    string filename;

    cout << "Enter name for new file: ";
    cin >> filename;

    ofstream fout(filename.c_str());

    fout << "For your eyes only!\n";
    cout << "Enter your secret number: ";
    float secret;
    cin >> secret;
    fout << "Your secret number is " << secret << endl;
    fout.close();

    ifstream fin(filename.c_str());
    cout << "Here are the contents of " << filename << ":\n";
    char ch;
    while (fin.get(ch)) {
        cout << ch;
    }
    cout << "Done\n";

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <fstream>
#include <cstdlib>

int main(int argc, char * argv[]) {
    using namespace std;

    ) {
        cerr << ] << " filename[s]\n";
        exit(EXIT_FAILURE);
    }

    ifstream fin;
    long count;
    ;
    char ch;

    ; file < argc; file++) {
        fin.open(argv[file]);
        if (!fin.is_open()) {
            cerr << "Could not open " << argv[file] << endl;
            fin.clear();
            continue;
        }
        count = ;
        while (fin.get(ch)) {
            count++;
        }
        cout << count << " characters in " << argv[file] << endl;
        total += count;
        fin.clear();
        fin.close();
    }

    cout << total << " characters in all files\n";

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>

const char * file = "guests.txt";

int main() {
    using namespace std;

    char ch;
    ifstream fin;
    fin.open(file);

    if (fin.is_open()) {
        cout << "Here are the current contents of the "
            << file << " file:\n";
        while (fin.get(ch)) {
            cout << ch;
        }
        fin.close();
    }

    ofstream fout(file, ios::out | ios::app);
    if (!fout.is_open()) {
        cerr << "Can't open " << file << " file for output.\n";
        exit(EXIT_FAILURE);
    }

    cout << "Enter guest names (enter a blank line to quit):\n";
    string name;
    ) {
        fout << name << endl;
    }
    fout.close();

    fin.clear();
    fin.open(file);
    if (fin.is_open()) {
        cout << "Here are the new contents of the "
            << file << " file:\n";
        while (fin.get(ch)) {
            cout << ch;
        }
        fin.close();
    }

    cout << "Done.\n";

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdlib>

inline void eatline() {
    while (std::cin.get() != '\n') {
        continue;
    }
}

struct planet {
    ];
    double population;
    double g;
};

const char * file = "planets.dat";

int main() {
    using namespace std;
    planet pl;
    cout << fixed << right;

    ifstream fin;
    fin.open(file, ios_base::in | ios_base::binary);

    if (fin.is_open()) {
        cout << "Here are the current contents of the "
            << file << " file:\n";
        while (fin.read((char *)&pl, sizeof pl)) {
            cout << setw() << pl.name << ": "
                << setprecision() << setw() << pl.population
                << setprecision() << setw() << pl.g << endl;
        }
        fin.close();
    }

    ofstream fout(file, ios_base::out | ios_base::app | ios_base::binary);
    if (!fout.is_open()) {
        cerr << "Can't open " << file << " file for output:\n";
        exit(EXIT_FAILURE);
    }

    cout << "Enter planet name (enter a blank line to quit):\n";
    cin.);
    ] != '\0') {
        eatline();
        cout << "Enter planetary population: ";
        cin >> pl.population;
        cout << "Enter planet's acceleration of gravity: ";
        cin >> pl.g;
        eatline();
        fout.write((char *)&pl, sizeof pl);
        cout << "Enter planet name (enter a blank line "
            "to quit):\n";
        cin.);
    }
    fout.close();

    fin.clear();
    fin.open(file, ios_base::in | ios_base::binary);
    if (fin.is_open()) {
        cout << "Here are the new contents of the "
            << file << " file:\n";
        while (fin.read((char *)&pl, sizeof pl)) {
            cout << setw() << pl.name << ": "
                << setprecision() << setw() << pl.population
                << setprecision() << setw() << pl.g << endl;
        }
        fin.close();
    }
    cout << "Done.\n";

    cin.get();

    ;
}

#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdlib>

;

struct planet {
    char name[LIM];
    double population;
    double g;
};

const char * file = "planets.dat";

inline void eatline() {
    while (std::cin.get() != '\n') {
        continue;
    }
}

int main() {
    using namespace std;
    planet pl;
    cout << fixed;

    fstream finout;
    finout.open(file, ios_base::in | ios_base::out | ios_base::binary);

    ;
    if (finout.is_open()) {
        finout.seekg();
        cout << "Here are the current contents of the "
            << file << " file:\n";
        while (finout.read((char *)&pl, sizeof pl)) {
            cout << ct++ << ": " << setw(LIM) << pl.name << ": "
                << setprecision() << setw() << pl.population
                << setprecision() << setw() << pl.g << endl;
        }
        if (finout.eof()) {
            finout.clear();
        } else {
            cerr << "Error in reading " << file << ".\n";
            exit(EXIT_FAILURE);
        }
    } else {
        cerr << file << " could not be opened -- bye.\n";
        exit(EXIT_FAILURE);
    }

    cout << "Enter the record number you wish to change: ";
    long rec;
    cin >> rec;
    eatline();
     || rec >= ct) {
        cerr << "Invalid record number -- bye\n";
        exit(EXIT_FAILURE);
    }
    streampos place = rec * sizeof pl;
    finout.seekg(place);
    if (finout.fail()) {
        cerr << "Error on attempted seek\n";
        exit(EXIT_FAILURE);
    }

    finout.read((char *)&pl, sizeof pl);
    cout << "Your selection:\n";
    cout << rec << ": " << setw(LIM) << pl.name << ": "
        << setprecision() << setw() << pl.population
        << setprecision() << setw() << pl.g << endl;
    if (finout.eof()) {
        finout.clear();
    }

    cout << "Enter planet name: ";
    cin.get(pl.name, LIM);
    eatline();
    cout << "Enter planetary population: ";
    cin >> pl.population;
    cout << "Enter planet's acceleration of gravity: ";
    cin >> pl.g;
    finout.seekp(place);
    finout.write((char *)&pl, sizeof pl) << flush;
    if (finout.fill()) {
        cerr << "Error on attempted write\n";
        exit(EXIT_FAILURE);
    }

    ct = ;
    finout.seekg();
    cout << "Here are the new contents of the " << file
        << " file:\n";
    while (finout.read((char *)&pl, sizeof pl)) {
        cout << ct++ << ": " << setw(LIM) << pl.name << ": "
            << setprecision() << setw() << pl.population
            << setprecision() << setw() << pl.g << endl;
    }
    finout.close();
    cout << "Done.\n";

    cin.get();

    ;
}

#include <iostream>
#include <sstream>
#include <string>

int main() {
    using namespace std;
    ostringstream outstr;
    string hdisk;
    cout << "What's the name of your hard disk? ";
    getline(cin, hdisk);
    int cap;
    cout << "What's its capacity in GB? ";
    cin >> cap;
    outstr << "The hard disk " << hdisk << " has a capacity of "
        << cap << " gigabytes.\n";
    string result = outstr.str();
    cout << result;

    cin.get();
    cin.get();

    ;
}

#include <iostream>
#include <sstream>
#include <string>

int main() {
    using namespace std;
    string lit = "It was a dark and stormy day, and "
        " the full moon glowed brilliantly. ";
    istringstream instr(lit);
    string word;
    while (instr >> word) {
        cout << word << endl;
    }

    cin.get();

    ;
}

#include <iostream>

inline double f(double tf) {
    return 5.0 * (tf - 32.0) / 9.0;
}

int main() {
    using namespace std;
    double tc = 21.5;
    double && rd1 = 7.07;
    double && rd2 = 1.8 * tc + 32.0;
    double && rd3 = f(rd2);

    cout << " tc value and address: " << tc << ", " << &tc << endl;
    cout << "rd1 value and address: " << rd1 << ", " << &rd1 << endl;
    cout << "rd2 value and address: " << rd2 << ", " << &rd2 << endl;
    cout << "rd3 value and address: " << rd3 << ", " << &rd3 << endl;

    cin.get();

    ;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <ctime>

const long Size1 = 39L;
 * Size1;
 * Size2;

 == ; }
 == ; }

int main() {
    using std::cout;
    std::vector<int> numbers(Size1);

    std::srand(std::time());
    std::generate(numbers.begin(), numbers.end(), std::rand);

    cout << "Samples size = " << Size1 << '\n';

    int count3 = std::count_if(numbers.begin(), numbers.end(), f3);
    cout << "Count of numbers divisible by 3: " << count3 << '\n';

    int count13 = std::count_if(numbers.begin(), numbers.end(), f13);
    cout << "Count of numbers divisible by 13: " << count13 << "\n\n";

    numbers.resize(Size2);
    std::generate(numbers.begin(), numbers.end(), std::rand);
    cout << "Sample size = " << Size2 << '\n';

    class f_mod {
    private:
        int dv;
    public:
        f_mod() : dv(d) {}
        ;  }
    };

    count3 = std::count_if(numbers.begin(), numbers.end(), f_mod());
    cout << "Count of numbers divisible by 3: " << count3 << '\n';
    count13 = std::count_if(numbers.begin(), numbers.end(), f_mod());
    cout << "Count of numbers divisible by 13: " << count13 << "\n\n";

    numbers.resize(Size3);
    std::generate(numbers.begin(), numbers.end(), std::rand);
    cout << "Sample size = " << Size3 << '\n';

    count3 = std::count_if(numbers.begin(), numbers.end(), []( == ;});
    cout << "Count of numbers divisible by 3: " << count3 << '\n';
    count13 = std::count_if(numbers.begin(), numbers.end(), []( == ; });
    cout << "Count of numbers divisible by 13: " << count13 << '\n';

    std::cin.get();
    std::cin.get();

    ;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <ctime>

const long Size = 390000L;

int main() {
    using std::cout;
    std::vector<int> numbers(Size);

    std::srand(std::time());
    std::generate(numbers.begin(), numbers.end(), std::rand);
    cout << "Sample size = " << Size << '\n';

     == ; });
    cout << "Count of numbers divisible by 3: " << count3 << '\n';

    ;
    std::for_each(numbers.begin(), numbers.end(), [&count13]( == ; });
    cout << "Count of numbers divisible by 13: " << count13 << '\n';

    count3 = count13 = ;
    std::for_each(numbers.begin(), numbers.end(), [&]( == ; count13 += x %  == ; });

    cout << "Count of numbers divisible by 3: " << count3 << '\n';
    cout << "Count of numbers divisible by 13: " << count13 << '\n';

    std::cin.get();

    ;
}

#include <iostream>

template<typename T, typename F>
T use_f(T v, F f) {
    ;
    count++;
    std::cout << " use_f count = " << count
        << ", &count = " << &count << std::endl;
    return f(v);
}

class Fp {
private:
    double z_;
public:
    Fp(double z = 1.0) : z_(z) { }
    double operator()(double p) {
        return z_ * p;
    }
};

class Fq {
private:
    double z_;
public:
    Fq(double z = 1.0) : z_(z) { }
    double operator()(double q) {
        return z_ + q;
    }
};

#include <iostream>
#include "somedefs.h"

double dub(double x) {
    return 2.0 * x;
}
double square(double x) {
    return x * x;
}

int main() {
    using std::cout;
    using std::endl;

    double y = 1.21;
    cout << "Function pointer dub:\n";
    cout << " " << use_f(y, dub) << endl;

    cout << "Function pointer square:\n";
    cout << " " << use_f(y, square) << endl;

    cout << "Function object Fp:\n";
    cout << " " << use_f(y, Fp(5.0)) << endl;

    cout << "Function object Fq:\n";
    cout << " " << use_f(y, Fq(5.0)) << endl;

    cout << "Lambda expression 1:\n";
    cout << " " << use_f(y, [](double u) { return u * u; }) << endl;

    cout << "Lambda expression 2:\n";
    cout << " " << use_f(y, [](double u) { return u + u / 2.0; }) << endl;

    std::cin.get();

    ;
}

#include <iostream>
#include <functional>
#include "somedefs.h"

double dub(double x) { return 2.0 * x; }
double square(double x) { return x * x; }

int main() {
    using std::cout;
    using std::endl;
    using std::function;

    double y = 1.21;
    function<double(double)> ef1 = dub;
    function<double(double)> ef2 = square;
    function<double(double)> ef3 = Fq(10.0);
    function<double(double)> ef4 = Fp(10.0);
    function<double(double)> ef5 = [](double u) { return u * u; };
    function<double(double)> ef6 = [](double u) { return u + u / 2.0; };

    cout << "Function pointer dub:\n";
    cout << " " << use_f(y, ef1) << endl;
    cout << "Function pointer square:\n";
    cout << " " << use_f(y, ef2) << endl;
    cout << "Function object Fp:\n";
    cout << " " << use_f(y, ef3) << endl;
    cout << "Function object Fq:\n";
    cout << " " << use_f(y, ef4) << endl;
    cout << "Lambda expression 1:\n";
    cout << " " << use_f(y, ef5) << endl;
    cout << "Lambda expression 2:\n";
    cout << " " << use_f(y, ef6) << endl;

    std::cin.get();

    ;
}

#include <iostream>
#include <string>

void show_list3() {}

template<typename T, typename... Args>
void show_list3(T value, Args... args) {
    std::cout << value << ", ";
    show_list3(args...);
}

int main() {
    ;
    double x = 2.71828;
    std::string mr = "Mr. String objects!";
    show_list3(n, x);
    show_list3(x * x, , mr);

    std::cin.get();

    ;
}

#include <iostream>
#include <string>

void show_list() {}

template<typename T>
void show_list(const T& value) {
    std::cout << value << '\n';
}

template<typename T, typename... Args>
void show_list(const T& value, const Args&... args) {
    std::cout << value << ", ";
    show_list(args...);
}

int main() {
    ;
    double x = 2.71828;
    std::string mr = "Mr. String objects!";
    show_list(n, x);
    show_list(x * x, , mr);

    std::cin.get();

    ;
}