cpp-primer-5th

CC prog1.cc

> echo %ERRORLEVEL%
0

bool b = 42;               // b is true
int i = b;                 // i has value 1
i = 3.14;                  // i has value 3
double pi = i;             // pi has value 3.0
unsigned char c = -1;      // assuming 8-bit chars, c has value 255
signed char c2 = 256;      // assuming chars, the value of c2 is undefined

int sum =0;
Sales_item item; // item has type Sales_item

// ok: price is defined and initialized before it is used to initialize discount
double price = 109.99;

// ok: call applyDiscount and use the returen value to initialized salePrice
double salePrice = applyDiscount(price, discount);

int units_sold = 0;
int units_sold = {0};
int units_sold{0};
int units_sold(0);

#include <iostream>

int main(int argc, char *argv[])
{
    long double ld = 3.14159;
    int a{ld};
    int b = {ld};
    std::cout << a << std::endl;
    std::cout << b << std::endl;
    return 0;
}


////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// $ g++ -std=c++11 01.cc                         //
// 01.cc: In function 'int main(int, char**)':    //
// 01.cc:6:13: warning: narrowing conversion of   //
// 'ld' from 'long double' to 'int' inside { }    //
// [-Wnarrowing]                                  //
//      int a{ld};                                //
//              ^                                 //
// 01.cc:7:16: warning: narrowing conversion of   //
// 'ld' from 'long double' to 'int' inside { }    //
// [-Wnarrowing]                                  //
//      int b = {ld};                             //
//                 ^                              //
// $ ./a.out                                      //
// 3                                              //
// 3                                              //
////////////////////////////////////////////////////

#include <iostream>

int main(int argc, char *argv[])
{
    long double ld = 3.14159;
    int c(ld), d = ld;

    std::cout << c << std::endl;
    std::cout << d << std::endl;

    return 0;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// $ g++ -std=c++11 02.cc                         //
// $ ./a.out                                      //
// 3                                              //
// 3                                              //
////////////////////////////////////////////////////

#include <iostream>

int reused = 42;      // resued has global scope
int main() {
    int unique = 0;   // unique has block scope
    std::cout << "use global reused " << reused << " unique is " << unique << std::endl;

    int reused = 0;   // new, local object named reused hides global reused
    std::cout << "use local reused  " << reused << " unique is " << unique << std::endl;

    std::cout << "explicityly request global reused " << ::reused << " unique is " << unique << std::endl;

    return 0;
}

//////////////////////////////////////////////////////
// <===================OUTPUT===================>   //
// use global reused 42 unique is 0                 //
// use local reused  0 unique is 0                  //
// explicityly request global reused 42 unique is 0 //
//////////////////////////////////////////////////////

int ival = 1024;
int &refVal = ival;   // refVal refers to (is another name for) ival

double dval = 3.14;
// Error; initializer must be an int object!
int &refVal5 = dval;

// Error! initializer must be an object
int &refVal4 = 10;

double dval;
double *pd = &dval;    // ok: initializer is the address of a double
double *pd2 = pd;      // ok: initializer is a pointer to double

int *pi = pd;          // error: types of pi and pd differ
pi = &dval;            // error: assigning the address of a double to a pinter to int

#include <iostream>

using namespace std;
int main(int argc, char *argv[])
{
    int ival = 42;
    int *p = &ival;
    // * yields the object to which p points
    cout << *p << endl;

    // * yields the object; we assign a new value to ival throught p
    *p = 0;
    cout << *p << endl;
    cout << ival << endl;
    return 0;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// 42                                             //
// 0                                              //
// 0                                              //
////////////////////////////////////////////////////

#include <iostream>
#include <cstdlib>

int main(int argc, char *argv[])
{
    //////////////////////////////////////////////////
    // use to include nullptr g++ --std=c++11 06.cc //
    //////////////////////////////////////////////////
    int *p1 = nullptr;
    int *p2 = 0;
    NULL is include in cstdlib
    ///////////////////////////////////////////////////////////
    // Modern C++ programs generally should avoid using NULL //
    // and use nullptr instead                               //
    ///////////////////////////////////////////////////////////
    int *p3 = NULL;
    return 0;
}

#include <iostream>
#include <cstdlib>

int main(int argc, char *argv[])
{
    int *p4 = NULL;

    int zero = 0;
    ///////////////////////////////////////////////////////////////////////////////
    // 07.cc:9:15: error: invalid conversion from 'int' to 'int*' [-fpermissive] //
    //  int *p5 = zero;                                                          //
    //            ^                                                              //
    ///////////////////////////////////////////////////////////////////////////////
    int *p5 = zero;
    return 0;
}

#include <iostream>

using namespace std;
int main(int argc, char *argv[])
{
    double obj = 3.14, *pd = &obj;

    void *pv = &obj;
    pv = pd;
    /////////////////////////////////////////////////////////////////
    // 08.cc:10:14: error: 'void*' is not a pointer-to-object type //
    //  cout << *pv << endl;                                       //
    //           ^                                                 //
    /////////////////////////////////////////////////////////////////
    cout << *pv << endl;
    return 0;
}

int *p1;  // Way1: p1 is a pointer to int
int* p2;  // Way2: p2 is a pointer to int

int* p1, p2; // p1 is a pinter to int; p2 is an int

#include <iostream>

using namespace std;
int main(int argc, char *argv[])
{
    int ival = 1024;
    int *pi = &ival;        // pi points to an int
    int **ppi = &pi;        // ppi points to a pointer to an int

    cout << "The value of ival\n"
         << "direct value:   " << ival << "\n"
         << "indirect value: " << *pi  << "\n"
         << "doubly indirect value: " << **ppi
         << endl;
    return 0;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// The value of ival                              //
// direct value:   1024                           //
// indirect value: 1024                           //
// doubly indirect value: 1024                    //
////////////////////////////////////////////////////

const int ci = 1024;
const int &r1 = ci;     // OK: both reference and underlying object are const
r1 = 42;                // error: r1 is a reference to const

const int ci = 1024;
int &r2 = ci;        // error: non const reference to a const object!

#include <iostream>

using namespace std;
int main(int argc, char *argv[])
{
    double dval = 3.14;
    ////////////////////////////////////////////////////////////////
    // We can initialize a reference to const from any expression //
    // that can be converted to the type of reference             //
    ////////////////////////////////////////////////////////////////
    const int &ri = dval;

    cout << "ri is " << ri << endl;
    return 0;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// ri is 3                                        //
////////////////////////////////////////////////////

const int temp = dval;      // create a temporary const int from the double
const int &ri = temp;       // bind ri to that temporary

#include <iostream>

using namespace std;
int main(int argc, char *argv[])
{
    int a1 = 0;
    int a2 = 1;
    const int *p1 = &a1;
    cout << *p1 << endl;
    p1 = &a2;
    cout << *p1 << endl;

    int *const p2 = &a1;
    cout << *p2 << endl;

    //////////////////////////////////////////////////////////////
    // 15.cc:16:8: error: assignment of read-only variable 'p2' //
    //  p2 = &a2;                                               //
    //     ^                                                    //
    //////////////////////////////////////////////////////////////
    // p2 = &a2;
    return 0;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// 0                                              //
// 1                                              //
// 0                                              //
////////////////////////////////////////////////////

#include <iostream>

using namespace std;
//constexpr function
constexpr int size() {
    return 15;
}

int main(int argc, char *argv[])
{
    constexpr int mf = 50;
    // constexpr
    constexpr int sz = size();

    cout << mf << endl;
    cout << sz << endl;
    return 0;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// 50                                             //
// 15                                             //
////////////////////////////////////////////////////

const int *p = nullptr;            // p is a pointer to a const int
constexpr int *q = nullptr;        // q is a const pointer to int

typedef double wages;   //wages is a synonym for double

using SI = Sales_item;     // SI is a synonym for Sales_item

#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    typedef char *pstring;
    const pstring cstr = 0; // cstr is a constnt pointer to char!!

    // NOT equal with previous one
    const char* cstr2 = 0;  // cstr2 is a pointer to const char
    return 0;
}

#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    int val1 = 3;
    int val2 = 4;
    auto item = val1 + val2;
    cout << item << endl;
    return 0;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// 7                                              //
////////////////////////////////////////////////////

auto sz = 0, pi = 3.14;    // error: inconsistent types for sz and pi

const int ci = i;
auto b = ci;         // b is an int (top-leve const in ci is dropped)
const auto f = ci;   // deduced type of ci is int; f has type const int

string s1;                 // default initialization; s1 is the empty string
string s2 = s1;            // s2 is a copy of s1
string s3 = "hiya";        // s3 is a copy of the string literal
string s4(10, 'c');        // s4 is cccccccccc

std::string s;
std::cin >> s;
std::cout << s;

#include <iostream>

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

int main(int argc, char *argv[])
{
    string word;
    while (cin >> word) {
        cout << word << endl;
    }
    return 0;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// > ./a.out                                      //
// 123 456 789                                    //
// 123                                            //
// 456                                            //
// 789                                            //
////////////////////////////////////////////////////

#include <iostream>

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

int main(int argc, char *argv[])
{
    string word;
    while (getline(cin, word)) {
        ////////////////////////////////////////////////////////////////
        // The newline that cuses getline to return is discarded; the //
        // newline  is not stored in the string                       //
        ////////////////////////////////////////////////////////////////
        cout << word << endl;
    }
    return 0;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// > ./a.out                                      //
// 123 456 789                                    //
// 123 456 789                                    //
////////////////////////////////////////////////////

#include <iostream>

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

int main(int argc, char *argv[])
{
    string word = "hello world";
    cout << word.empty() << endl;
    cout << word.size() << endl;

    return 0;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// 0                                              //
// 11                                             //
////////////////////////////////////////////////////

auto len = line.size();   // len has type string::size_type

#include <iostream>

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

int main(int argc, char *argv[])
{
    int n = -5;
    string word = "hello world";
    cout << word.size() << endl;
    cout << (word.size() > n ? "size is bigger than -5 !": "size is small than -5!")
         << endl;
    return 0;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// 11                                             //
// size is small than -5!                         //
////////////////////////////////////////////////////

string st1(10, 'c'), st2;
//assignment : replace contents of st1 with a copy of st2
// both st1 and st2 are now the empty string
st1 = st2;

#include <iostream>

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

int main(int argc, char *argv[])
{
    string s1 = "hello", s2 = "world\n";
    string s3 = s1 + s2;
    cout << s3;
    return 0;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// helloworld                                     //
////////////////////////////////////////////////////

string s4 = s1 + ", ";       // ok: adding a string and a literal
string s5 = "hello" + ", ";  // error! no string operand
string s6 = s1 + ", " + "world"; // ok: each + has a string operand
string s7 = "hello" + ", " + s2; // error! can't add string literals

vector<string> svec;    // default initialization; svec has no elements

vector<int> ivec;

vector<int> ivec2(ivec);
vector<int> ivec3 = ivec;

vector<string> articles = {"a", "an", "the"};

vector<int> ivec(10, -1);        // ten int elements, each initialized to -1
vector<string> svec(10, "hi!");  // ten strings; each element is "hi!"

vector<string> svec(10);   // ten elements, each an empty string

vector<int> v2;

for (int i = 0; i != 100; ++i) {
    v2.push_back(i); // append sequential integers to v2
}

#include <iostream>
#include <vector>

using std::cout;
using std::endl;
using std::vector;

int main(int argc, char *argv[])
{
    vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9};
    for (auto &i : v) {
        i *= i;
    }
    for (auto i : v) {
        cout << i << " ";
    }
    cout << endl;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// 1 4 9 16 25 36 49 64 81                        //
////////////////////////////////////////////////////

vector<int>::size_type //ok
vector::size_type      //error

vector<int> ivec;      // empty vector
for (decltype(ivec.size()) ix = 0; ix != 10; ++ix) {
    ivec[ix] = ix;     // disaster: ivec has no elements
}

#include <iostream>
#include <vector>

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

int main(int argc, char *argv[])
{
    string s("some string");
    if (s.begin() != s.end()) {
        auto it = s.begin();
        *it = toupper(*it);
    }
    cout << s << endl;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// Some string                                    //
////////////////////////////////////////////////////

#include <iostream>
#include <vector>

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

int main(int argc, char *argv[])
{
    string s("some string");
     for (auto it = s.begin(); it != s.end() && !isspace(*it); ++it) {
        *it = toupper(*it);
    }
    cout << s << endl;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// SOME string                                    //
////////////////////////////////////////////////////

vector<int> v;
const vector<int> cv;
auto it1 = v.begin();          // it1 has type vector<int>::iterator
auto it2 = cv.begin();         // it2 has type vector<int>::const_iterator

vector<int> v;
auto it3 = v.cbegin();   // it3 has type vector<int>::const_iterator

// text must be sorted
// beg and end will denote the range we're searching
auto beg = text.begin(), end = text.end();
auto mid = text.begin() + (end - beg) / 2;

while (mid != end && *mid != sought) {
    if (sought < *mid) {
        end = mid;
    } else {
        beg = mid + 1;
    }
    mid = beg + (end - beg) / 2;
}

unsigned cnt = 42; // not a constant expression
constexpr unsigned sz = 42; // const expression

int arr[10];       // array of ten ints
int *parr[sz];     // array of 42 pointers to int
string bad[cnt];   // error: cnt is not a constant expression
string strs[get_size()]; // ok if get_size is constexpr, error otherwise

const unsigned sz = 3;
int ial[sz] = {0, 1, 2};      // array of three ints with values 0, 1, 2
int a2[] = {0, 1, 2};         // anarray of dimension 3
int a3[5] = {0, 1, 2};        // equivalent to a3[] = {0, 1, 2, 0, 0}
string a4[3] = {"hi", "bye"};  // same as a4[] = {"hi", "bye", ""}
int a5[2] = {0, 1, 2};        // error: too many initializers

char a3[] = "C++";     // null terminator added automatically
const char a4[6] = "Daniel";   // error:no spaces for the null!

char a1[] = {'c', '+', '+'};
char a2[] = {'c', '+', '+', '\0'};

int a[] = {0, 1, 2};
int a2[] = a;          // error: can not initialize one array with another
a2 = a;                // error: cannot assign one array to another

string nums[] = {"one", "two", "three"};
string *p2 = nums;     // equivalent to p2 = &nums[0]

int ia[] = {0, 1, 2, 3, 4};    // ia is an array of ten ints
auto ia2(ia);                  // ia2 is an int* that points to the first element in ia
ia2 = 42;                      // error: ia2 is a pointer, and we can't assign an int to a pointer

decltype(ia) ia3 = {0, 1, 2, 3, 4};
ia3 = p;       // error: can't assign an int* to an array
ia3[4] = i;    // ok: assign the value of i to an element in ia3

#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    int *pbeg = begin(arr);
    int *pend = end(arr);
    while (pbeg != pend && *pbeg >=0) {
        cout << *pbeg << " ";
        ++pbeg;
    }
    cout << endl;
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// $ g++ --std=c++11 13.cc                        //
// $ ./a.out                                      //
// 0 1 2 3 4 5 6 7 8 9                            //
////////////////////////////////////////////////////

#include <iostream>
#include <vector>

using namespace std;

void display(std::vector<int> someV) {
    for (std::vector<int>::const_iterator ite = someV.begin(); ite < someV.cend(); ++ite) {
        std::cout << *ite << "  ";
    }
    std::cout << std::endl;
}

int main(int argc, char *argv[])
{
    int int_arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

    vector<int> ivec(begin(int_arr), end(int_arr));
    display(ivec);

    vector<int> subVec(int_arr + 1, int_arr + 4);
    display(subVec);
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// 0  1  2  3  4  5  6  7  8  9                   //
// 1  2  3                                        //
////////////////////////////////////////////////////

while (cin >> s && s != sought)
    ; // null statment

while (iter != save.end());
    ++iter;

while (val <= 10) {
    sum += val;
    ++val;
}

char ch = getVal();
int ival = 42;

switch(ch) {
case 3.14: // error: noninteger as case label
case ival: // error: nonconstant as case label
// ...

while (condition)
    statement

for (initializer; condition; expression)
    statement

for (declaration : expression)
    statement

vector<int> v = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
// range variable must be a reference so we can write to the elements
for (auto &r : v)
    r *= 2

do
    statement;
while (condition);

Sales_item item1, item2;

cin >> item1 >> item2;

// first check that item1 and item2 represent the same book
if (item1.isbn() != item2.isbn()) {
    throw runtime_error("Data must refer to same ISBN");
}

// if we're still here, the ISBN are the same
cout << item1 + item2 << endl;