LGDSNX

C++ Primer(第五版) 第七章练习答案

C++ Primer(第五版) 第七章练习答案
- - 7.1
  - 7.2
  - 7.3
  - 7.4
  - 7.5
  - 7.6
  - 7.7
  - 7.8
  - 7.9
  - 7.10
  - 7.11
  - 7.12
  - 7.13
  - 7.14
  - 7.15
  - 7.16
  - 7.17
  - 7.18
  - 7.19
  - 7.20
  - 7.21
  - 7.22
  - 7.23
  - 7.24
  - 7.25
  - 7.26
  - 7.27
  - 7.28
  - 7.29
  - 7.30
  - 7.31
  - 7.32
  - 7.33
  - 7.34
  - 7.35
  - 7.36
  - 7.37
  - 7.38
  - 7.39
  - 7.40.cc
  - 7.40.h
  - 7.41.cc
  - 7.41.h
  - 7.42
  - 7.43
  - 7.44
  - 7.45
  - 7.46
  - 7.47
  - 7.48
  - 7.49
  - 7.50
  - 7.51
  - 7.52
  - 7.53
  - 7.54
  - 7.55
  - 7.56
  - 7.57.cc
  - 7.57.h
  - 7.58

7.1

#include 
#include 
#include "../2/2_40.h"

using namespace std;

int main()
{
     
    Sales_data total;

    if (cin >> total.bookNo >> total.units_sold >> total.revenue)
    {
     
        Sales_data trans;

        while (cin >> trans.bookNo >> trans.units_sold >> trans.revenue)
        {
     
            // 书名相同
            if (total.bookNo == trans.bookNo)
            {
     
                total.units_sold += trans.units_sold;
                total.revenue += trans.revenue;
            }
            else // 不同输出第一个
            {
     
                cout << total.bookNo << " "
                     << total.units_sold << " "
                     << total.revenue << endl;
                // 第二个 赋值 给 第一个
                total.bookNo = trans.bookNo;
                total.units_sold = trans.units_sold;
                total.revenue = trans.revenue;
            }
        }
        // 输出最后一个
        cout << total.bookNo << " "
             << total.units_sold << " "
             << total.revenue << endl;
    }
    else
    {
     
        cerr << "No data?!" << endl;
        return -1;
    }

    return 0;
}

7.2

#include 

struct Sales_data {
     

    // 返回书号
    std::string isbn() const {
      return bookNo; }
    // +=
    Sales_data& combine(const Sales_data &rhs);

    // 书号
    std::string bookNo;
    // 售卖单位
    unsigned units_sold = 0;
    // 收入
    double revenue = 0.0;
};

inline
Sales_data& Sales_data::combine(const Sales_data &rhs)
{
     
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;

    return *this;
}

7.3

#include 
#include 
#include "7_2.h"

using namespace std;

int main()
{
     
    Sales_data total;

    if (cin >> total.bookNo >> total.units_sold >> total.revenue)
    {
     
        Sales_data trans;

        while (cin >> trans.bookNo >> trans.units_sold >> trans.revenue)
        {
     
            // 书名相同
            if (total.isbn() == trans.isbn())
            {
     
                total.combine(trans);
            }
            else // 不同输出第一个
            {
     
                cout << total.bookNo << " "
                     << total.units_sold << " "
                     << total.revenue << endl;
                // 第二个 赋值 给 第一个
                total.bookNo = trans.bookNo;
                total.units_sold = trans.units_sold;
                total.revenue = trans.revenue;
            }
        }
        // 输出最后一个
        cout << total.bookNo << " "
             << total.units_sold << " "
             << total.revenue << endl;
    }
    else
    {
     
        cerr << "No data?!" << endl;
        return -1;
    }

    return 0;
}

7.4

#include 


struct Person {
     
    // 名字
    std::string name;
    // 地址
    std::string address;
};

7.5

#include 

/**
 * 因为不用更改 this 所以是 const
 */

struct Person {
     

    // 获取名字
    std::string getname() const {
      return name; }
    // 获取地址
    std::string getaddress() const {
      return address; }

    // 名字
    std::string name;
    // 地址
    std::string address;
};

7.6

#include 
#include 


struct Sales_data {
     

    // 返回书号
    std::string isbn() const {
      return bookNo; }
    // +=
    Sales_data& combine(const Sales_data &rhs);

    // 书号
    std::string bookNo;
    // 售卖单位
    unsigned units_sold = 0;
    // 收入
    double revenue = 0.0;
};

inline
Sales_data& Sales_data::combine(const Sales_data &rhs)
{
     
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;

    return *this;
}

// 辅助函数

// +
Sales_data add(const Sales_data &lhs, const Sales_data &rhs)
{
     
    Sales_data sum = lhs;
    sum.combine(rhs);

    return sum;
}

// 输入
std::istream &read(std::istream &is, Sales_data &item)
{
     
    is >> item.bookNo
       >> item.units_sold
       >> item.revenue;

    return is;
}

// 输出
std::ostream &print(std::ostream &os, const Sales_data &item)
{
     
    os << item.bookNo << " "
       << item.units_sold << " "
       << item.revenue;

    return os;
}

7.7

#include 
#include 
#include "7_6.h"

using namespace std;

int main()
{
     
    Sales_data total;

    if (read(cin, total))
    {
     
        Sales_data trans;

        while (read(cin, trans))
        {
     
            // 书名相同
            if (total.isbn() == trans.isbn())
            {
     
                total.combine(trans);
            }
            else // 不同输出第一个
            {
     
                print(cout, total) << endl;
                // 第二个 赋值 给 第一个
                total = trans;
            }
        }
        // 输出最后一个
        print(cout, total) << endl;
    }
    else
    {
     
        cerr << "No data?!" << endl;
        return -1;
    }

    return 0;
}

7.8


/**
 * read 要写值
 * print 不用写值
 */

7.9

#include 
#include 


struct Person {
     

    // 获取名字
    std::string getname() const {
      return name; }
    // 获取地址
    std::string getaddress() const {
      return address; }

    // 名字
    std::string name;
    // 地址
    std::string address;
};

// 辅助函数

// 输入
inline
std::istream &read(std::istream &is, Person &item)
{
     
    is >> item.name >> item.address;

    return is;
}

// 输出
inline
std::ostream &print(std::ostream &os, const Person &item)
{
     
    os << item.name << " "
       << item.address;

    return os;
}

7.10


/**
 * 两个输入正确为真
 */

7.11

#include 
#include 

struct Sales_data {
     

    // 构造函数
    Sales_data() = default;
    Sales_data(std::istream &is) {
      read(is, *this); }
    Sales_data(const std::string &s) : bookNo(s) {
      }
    Sales_data(const std::string &s, unsigned u, double d) : bookNo(s), units_sold(u), revenue(d) {
      }

    // 返回书号
    std::string isbn() const {
      return bookNo; }
    // +=
    Sales_data& combine(const Sales_data &rhs);

    // 书号
    std::string bookNo;
    // 售卖单位
    unsigned units_sold = 0;
    // 收入
    double revenue = 0.0;
};

inline
Sales_data& Sales_data::combine(const Sales_data &rhs)
{
     
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;

    return *this;
}

// 辅助函数

// +
inline
Sales_data add(const Sales_data &lhs, const Sales_data &rhs)
{
     
    Sales_data sum = lhs;
    sum.combine(rhs);

    return sum;
}

// 输入
inline
std::istream &read(std::istream &is, Sales_data &item)
{
     
    is >> item.bookNo
       >> item.units_sold
       >> item.revenue;

    return is;
}

// 输出
inline
std::ostream &print(std::ostream &os, const Sales_data &item)
{
     
    os << item.bookNo << " "
       << item.units_sold << " "
       << item.revenue;

    return os;
}

7.12

#include 
#include 

// 声明
struct Sales_data;

Sales_data add(const Sales_data &lhs, const Sales_data &rhs);
std::istream &read(std::istream &is, Sales_data &item);
std::ostream &print(std::ostream &os, const Sales_data &item);


struct Sales_data {
     

    // 构造函数
    Sales_data() = default;
    Sales_data(std::istream &is) {
      read(is, *this); }
    Sales_data(const std::string &s) : bookNo(s) {
      }
    Sales_data(const std::string &s, unsigned u, double d) : bookNo(s), units_sold(u), revenue(d) {
      }

    // 返回书号
    std::string isbn() const {
      return bookNo; }
    // +=
    Sales_data& combine(const Sales_data &rhs);

    // 书号
    std::string bookNo;
    // 售卖单位
    unsigned units_sold = 0;
    // 收入
    double revenue = 0.0;
};

inline
Sales_data& Sales_data::combine(const Sales_data &rhs)
{
     
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;

    return *this;
}


// 辅助函数

// +
inline
Sales_data add(const Sales_data &lhs, const Sales_data &rhs)
{
     
    Sales_data sum = lhs;
    sum.combine(rhs);

    return sum;
}

// 输入
inline
std::istream &read(std::istream &is, Sales_data &item)
{
     
    is >> item.bookNo
       >> item.units_sold
       >> item.revenue;

    return is;
}

// 输出
inline
std::ostream &print(std::ostream &os, const Sales_data &item)
{
     
    os << item.bookNo << " "
       << item.units_sold << " "
       << item.revenue;

    return os;
}

7.13

#include 
#include 
#include "7_12.h"

using namespace std;

int main()
{
     
    Sales_data total(cin);

    if (cin)
    {
     
        do
        {
     
            Sales_data trans(cin);

            // 书名相同
            if (total.isbn() == trans.isbn())
            {
     
                total.combine(trans);
            }
            else // 不同输出第一个
            {
     
                print(cout, total) << endl;
                // 第二个 赋值 给 第一个
                total = trans;
            }

        } while(cin);
        // 输出最后一个
        // print(cout, total) << endl;
    }
    else
    {
     
        cerr << "No data?!" << endl;
        return -1;
    }

    return 0;
}

7.14


Sales_data() : bookNo(std::string()), units_sold(0), revenue(0.0) {
      }

7.15

#include 
#include 

struct Person;

std::istream &read(std::istream &is, Person &item);
std::ostream &print(std::ostream &os, const Person &item);


struct Person {
     

    // 构造函数
    Person() = default;
    Person(std::istream &is) {
      read(is, *this); }
    Person(const std::string &s) : name(s) {
      }
    Person(const std::string &n, const std::string &a) : name(n), address(a) {
      }

    // 获取名字
    std::string getname() const {
      return name; }
    // 获取地址
    std::string getaddress() const {
      return address; }

    // 名字
    std::string name;
    // 地址
    std::string address;
};

// 辅助函数

// 输入
inline
std::istream &read(std::istream &is, Person &item)
{
     
    is >> item.name >> item.address;

    return is;
}

// 输出
inline
std::ostream &print(std::ostream &os, const Person &item)
{
     
    os << item.name << " "
       << item.address;

    return os;
}

7.16


/**
 * 没有
 * 接口
 * 数据成员
 */

7.17


/**
 * 默认访问权限不一样
 * struct public
 * class private
 */

7.18


/**
 * 隐藏实现细节
 * 保护数据
 */

7.19

#include 
#include 

class Person;

std::istream &read(std::istream &is, Person &item);
std::ostream &print(std::ostream &os, const Person &item);


class Person {
     

friend std::istream &read(std::istream &is, Person &item);
friend std::ostream &print(std::ostream &os, const Person &item);

public:
    // 构造函数
    Person() = default;
    Person(std::istream &is) {
      read(is, *this); }
    Person(const std::string &s) : name(s) {
      }
    Person(const std::string &n, const std::string &a) : name(n), address(a) {
      }

    // 获取名字
    std::string getname() const {
      return name; }
    // 获取地址
    std::string getaddress() const {
      return address; }
private:
    // 名字
    std::string name;
    // 地址
    std::string address;
};

// 辅助函数

// 输入
inline
std::istream &read(std::istream &is, Person &item)
{
     
    is >> item.name >> item.address;

    return is;
}

// 输出
inline
std::ostream &print(std::ostream &os, const Person &item)
{
     
    os << item.name << " "
       << item.address;

    return os;
}

7.20



/**
 * 访问类的非公有成员
 * 方便调用非公有成员
 * 破化封装性
 */

7.21

#include 
#include 

class Sales_data {
     
friend std::istream &read(std::istream &is, Sales_data &item);
friend std::ostream &print(std::ostream &os, const Sales_data &item);
friend Sales_data add(const Sales_data &lhs, const Sales_data &rhs);
public:
    // 构造函数
    Sales_data() = default;
    Sales_data(std::istream &is) {
      read(is, *this); }
    Sales_data(const std::string &s) : bookNo(s) {
      }
    Sales_data(const std::string &s, unsigned u, double d) : bookNo(s), units_sold(u), revenue(d) {
      }
    // 返回书号
    std::string isbn() const {
      return bookNo; }
    // +=
    Sales_data& combine(const Sales_data &rhs);
private:
    // 书号
    std::string bookNo;
    // 售卖单位
    unsigned units_sold = 0;
    // 收入
    double revenue = 0.0;
};

// 辅助函数
Sales_data add(const Sales_data &lhs, const Sales_data &rhs);
std::istream &read(std::istream &is, Sales_data &item);
std::ostream &print(std::ostream &os, const Sales_data &item);

// 内联函数
inline
Sales_data& Sales_data::combine(const Sales_data &rhs)
{
     
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;

    return *this;
}

7.22

#include 
#include 

class Person {
     
friend std::istream &read(std::istream &is, Person &item);
friend std::ostream &print(std::ostream &os, const Person &item);
public:
    // 构造函数
    Person() = default;
    Person(std::istream &is) {
      read(is, *this); }
    Person(const std::string &s) : name(s) {
      }
    Person(const std::string &n, const std::string &a) : name(n), address(a) {
      }
    // 获取名字
    std::string getname() const {
      return name; }
    // 获取地址
    std::string getaddress() const {
      return address; }
private:
    // 名字
    std::string name;
    // 地址
    std::string address;
};

// 辅助函数
std::istream &read(std::istream &is, Person &item);
std::ostream &print(std::ostream &os, const Person &item);

7.23

#include 

class Screen {
     
public:
    typedef std::string::size_type pos;
    
    Screen() = default;
    Screen(pos ht, pos wd) : height(ht), width(wd), contents(ht * wd, ' ') {
      }
    Screen(pos ht, pos wd, char ch) : height(ht), width(wd), contents(ht * wd, ch) {
      }

    // 获取光标
    char get() const {
      return contents[cursor]; }
    char get(pos ht, pos wd) const {
      return contents[ht * width + wd]; }
    // 移动光标
    Screen &move(pos ht, pos wd) {
      cursor = ht * width + wd; return *this; }
private:
    // 光标
    pos cursor = 0;
    // 高
    pos height = 0;
    // 宽
    pos width = 0;
    // 内容
    std::string contents;
};

7.24

#include 

class Screen {
     
public:
    typedef std::string::size_type pos;
    
    Screen() = default;
    Screen(pos ht, pos wd) : height(ht), width(wd), contents(ht * wd, ' ') {
      }
    Screen(pos ht, pos wd, char ch) : height(ht), width(wd), contents(ht * wd, ch) {
      }

    // 获取光标
    char get() const {
      return contents[cursor]; }
    char get(pos ht, pos wd) const {
      return contents[ht * width + wd]; }
    // 移动光标
    Screen &move(pos ht, pos wd) {
      cursor = ht * width + wd; return *this; }
private:
    // 光标
    pos cursor = 0;
    // 高
    pos height = 0;
    // 宽
    pos width = 0;
    // 内容
    std::string contents;
};

7.25



/**
 * 能
 * 如果类包含vector或者string成员，则其拷贝，赋值和销毁的合成版本能够正常工作
 */

7.26

#include 
#include 

class Sales_data {
     

friend std::istream &read(std::istream &is, Sales_data &item);
friend std::ostream &print(std::ostream &os, const Sales_data &item);
friend Sales_data add(const Sales_data &lhs, const Sales_data &rhs);

public:
    // 构造函数
    Sales_data() = default;
    Sales_data(std::istream &is) {
      read(is, *this); }
    Sales_data(const std::string &s) : bookNo(s) {
      }
    Sales_data(const std::string &s, unsigned u, double d) : bookNo(s), units_sold(u), revenue(d) {
      }

    // 返回书号
    std::string isbn() const {
      return bookNo; }
    // +=
    Sales_data& combine(const Sales_data &rhs);
    // 卖出数量
    double avg_price() const {
      return units_sold ? revenue / units_sold : 0; }
private:
    // 书号
    std::string bookNo;
    // 售卖单位
    unsigned units_sold = 0;
    // 收入
    double revenue = 0.0;
};

Sales_data add(const Sales_data &lhs, const Sales_data &rhs);
std::istream &read(std::istream &is, Sales_data &item);
std::ostream &print(std::ostream &os, const Sales_data &item);

inline
Sales_data& Sales_data::combine(const Sales_data &rhs)
{
     
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;

    return *this;
}

7.27

#include 
#include 

class Screen {
     
public:
    typedef std::string::size_type pos;
    
    Screen() = default;
    Screen(pos ht, pos wd) : height(ht), width(wd), contents(ht * wd, ' ') {
      }
    Screen(pos ht, pos wd, char ch) : height(ht), width(wd), contents(ht * wd, ch) {
      }

    // 获取光标
    char get() const {
      return contents[cursor]; }
    char get(pos ht, pos wd) const {
      return contents[ht * width + wd]; }
    // 移动光标
    Screen &move(pos ht, pos wd) {
      cursor = ht * width + wd; return *this; }
    // 输入
    Screen &set(char);
    Screen &set(pos, pos, char);
    // 显示
    Screen &display(std::ostream &os) {
      do_display(os); return *this; }
    const Screen &display(std::ostream &os) const {
      do_display(os); return *this; }
private:
    void do_display(std::ostream &os) const;
    // 光标
    pos cursor = 0;
    // 高
    pos height = 0;
    // 宽
    pos width = 0;
    // 内容
    std::string contents;
};

inline
Screen &Screen::set(char ch)
{
     
    contents[cursor] = ch;
    return *this;
}

inline
Screen &Screen::set(pos ht, pos wd, char ch)
{
     
    contents[ht * width + wd] = ch;
    return *this;
}

inline
void Screen::do_display(std::ostream &os) const
{
     
    for (pos i = 0; i != contents.size(); ++i)
    {
     
        os << contents[i];
        if (i % width == width - 1)
            os << std::endl;
    }
}

7.28



/**
 * 一样的输出
 * 对象没有改变
 */

7.29

#include 
#include 

class Screen {
     
public:
    typedef std::string::size_type pos;
    
    Screen() = default;
    Screen(pos ht, pos wd) : height(ht), width(wd), contents(ht * wd, ' ') {
      }
    Screen(pos ht, pos wd, char ch) : height(ht), width(wd), contents(ht * wd, ch) {
      }

    // 获取光标
    char get() const {
      return contents[cursor]; }
    char get(pos ht, pos wd) const {
      return contents[ht * width + wd]; }
    // 移动光标
    Screen move(pos ht, pos wd) {
      cursor = ht * width + wd; return *this; }
    // 输入
    Screen set(char);
    Screen set(pos, pos, char);
    // 显示
    Screen display(std::ostream &os) {
      do_display(os); return *this; }
    const Screen display(std::ostream &os) const {
      do_display(os); return *this; }
private:
    void do_display(std::ostream &os) const;
    // 光标
    pos cursor = 0;
    // 高
    pos height = 0;
    // 宽
    pos width = 0;
    // 内容
    std::string contents;
};

inline
Screen Screen::set(char ch)
{
     
    contents[cursor] = ch;
    return *this;
}

inline
Screen Screen::set(pos ht, pos wd, char ch)
{
     
    contents[ht * width + wd] = ch;
    return *this;
}

inline
void Screen::do_display(std::ostream &os) const
{
     
    for (pos i = 0; i != contents.size(); ++i)
    {
     
        os << contents[i];
        if (i % width == width - 1)
            os << std::endl;
    }
}

using namespace std;

int main()
{
     
    Screen myScreen(5, 5, 'X');
    myScreen.move(4, 0).set('#').display(cout);
    myScreen.display(cout);

    return 0;
}

7.30



/**
 * 可以同名
 * 代码多余
 */

7.31

struct X;
struct Y;

struct X {
     
    Y *p;
};

struct Y {
     
    X p;
};

7.32

#include 
#include 
#include "Screen.h"

class Window_mgr {
     
public:
    using ScreenIndex = std::vector<Screen>::size_type;

    void clear(ScreenIndex);
private:
    std::vector<Screen> screens{
     Screen(24, 80, ' ')};
};

inline
void Window_mgr::clear(ScreenIndex i)
{
     
    Screen &s = screens[i];
    s.contents = std::string(s.height * s.width, ' ');
}

7.33


/**
 * pos 未定义
 * SCreen::pos Screen::size() const
 * {
 *     return height * width;
 * }
 */

7.34


/**
 * 未定义标识符
 */

7.35

#include 
using std::string;

typedef string Type;
Type initVal(); // string

class Exercise {
     
public:
    typedef double Type; // 不允许重新定义类型名字
    Type setVal(Type); // double
    Type initVal(); // double
private:
    int val; 
};
// string            double
Type Exercise::setVal(Type parm)
{
     
    val = parm + initVal(); // Exercise::initVal();
    return val;
}

7.36


/**
 * rem 先初始化 base 未定义值
 */

struct X {
     
    X(int i, int j) : base(i), rem(base % j);
    // 换位
    int base, rem;
};

7.37

#include "../Sales_data/Sales_data.h"
#include 
using namespace std;

// istream
Sales_data first_item(cin);

int main()
{
     
    // 默认
    Sales_data next;
    // string
    Sales_data last("11111");

    return 0;
}

7.38


// 声明不提供默认实参, 定义提供
Sales_data(std::istream is& = std::cin);

7.39


/**
 * 不合法 有多个默认构造函数
 */

7.40.cc

#include 
#include 
#include "Date.h"
 
#define STR(i) (std::to_string(i))

// 日期
Date::Date() : tim(time(&tim)), t(localtime(&tim)), year(STR(t->tm_year + 1900)),
               month(STR(t->tm_mon + 1)), day(STR(t->tm_mday)), hour(STR(t->tm_hour)),
               minute(STR(t->tm_min)), second(STR(t->tm_sec)) {
      }
#undef STR

7.40.h

#ifndef DATE_H
#define DATE_H

#include 
#include 
#include 
#include 
 
// 日期
class Date{
     
friend std::ostream &operator<<(std::ostream&, const Date&);
public:
    Date();
private:
    time_t tim;
    struct tm *t;
    std::string year;
    std::string month;
    std::string day;
    std::string hour;
    std::string minute;
    std::string second;
};

#define SET std::setw(2) << std::setfill('0')

inline
std::ostream &operator<<(std::ostream &os, const Date &item)
{
     
    os << item.year << "/" << SET << item.month << "/"
       << SET << item.day << " -- " << SET << item.hour << ":"
       << SET << item.minute << ":" << SET << item.second;

    return os;
}
#undef SET

#endif

7.41.cc

#include "7_41.h"
#include 

// 成员函数

// 辅助函数

// +
Sales_data add(const Sales_data &lhs, const Sales_data &rhs)
{
     
    Sales_data sum = lhs;
    sum.combine(rhs);

    return sum;
}

// 输入
std::istream &read(std::istream &is, Sales_data &item)
{
     
    is >> item.bookNo
       >> item.units_sold
       >> item.revenue;

    return is;
}

// 输出
std::ostream &print(std::ostream &os, const Sales_data &item)
{
     
    os << item.bookNo << " "
       << item.units_sold << " "
       << item.revenue;

    return os;
}

int main()
{
     

    Sales_data data1;
    Sales_data data2(std::cin);
    Sales_data data3("xi");
    Sales_data data4("xi", 0, 0);
}

7.41.h

#ifndef SALES_DATA
#define SALES_DATA

/**
 * 2_40.h
 * 7_2.h
 */
 
#include 
#include 


class Sales_data {
     

friend std::istream &read(std::istream &is, Sales_data &item);
friend std::ostream &print(std::ostream &os, const Sales_data &item);
friend Sales_data add(const Sales_data &lhs, const Sales_data &rhs);

public:
    // 构造函数
    Sales_data() : Sales_data("", 0, 0) {
      puts("Sales_data()"); }
    Sales_data(std::istream &is) : Sales_data() {
      puts("Sales_data(std::istream&"); read(is, *this); }
    Sales_data(const std::string &s) : Sales_data(s, 0, 0) {
      puts("Sales_data(const std::string&)"); }
    Sales_data(const std::string &s, unsigned u, double d) : bookNo(s), units_sold(u), revenue(d) 
        {
      puts("Sales_data(const std::string&, unsigned, double)"); }

    // 返回书号
    std::string isbn() const {
      return bookNo; }
    // +=
    Sales_data& combine(const Sales_data &rhs);
    // 卖出数量
    double avg_price() const {
      return units_sold ? revenue / units_sold : 0; }
private:
    // 书号
    std::string bookNo;
    // 售卖单位
    unsigned units_sold = 0;
    // 收入
    double revenue = 0.0;
};

Sales_data add(const Sales_data &lhs, const Sales_data &rhs);
std::istream &read(std::istream &is, Sales_data &item);
std::ostream &print(std::ostream &os, const Sales_data &item);

inline
Sales_data& Sales_data::combine(const Sales_data &rhs)
{
     
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;

    return *this;
}
#endif

7.42


Date::Date(std::string &ye) : Date() {
      year = ye; }

7.43

#include 
#include 

struct NoDefuault {
     
    NoDefuault(int i) : i(i) {
      }
    int i = 0;
};

struct C {
     
    C() : nd(1) {
      }
    NoDefuault nd;
};

int main()
{
     
    C c;
    printf("%d\n", c.nd.i);
    std::vector<NoDefuault> d(10, 0);
    std::vector<C> e(10);

    return 0;
}

7.44


/**
 * 不合法
 * 没有默认构造函数
 */

7.45


/**
 * 合法
 * 有默认构造函数
 */

7.46



/**
 * a 正确 提供非默认构造函数, 或默认构造函数能构造类
 * b 错误 默认实参也是默认构造函数
 * c 你喜欢
 * d 错误 引用和指针数据成员没有 合成默认构造函数
 */

7.47


/**
 * 是
 * 只有书号没意义
 * 不能拷贝初始化
 */

7.48


/**
 * 正确构造
 * 转换成 string, 正确构造
 * 
 * 毫无影响
 */

7.49


/**
 * a string 转换成 Sales_data, 传入临时量的副本
 * b string 无法转换成 Sales_data &
 * a string 转换成 Sales_data, 传给常量引用 常量成员函数不能改变 this
 */

7.50

#include 
#include 

class Person {
     
friend std::istream &read(std::istream &is, Person &item);
friend std::ostream &print(std::ostream &os, const Person &item);
public:
    // 构造函数
    Person() = default;
    explicit Person(std::istream &is) {
      read(is, *this); }
    explicit Person(const std::string &s) : name(s) {
      }
    Person(const std::string &n, const std::string &a) : name(n), address(a) {
      }
    // 获取名字
    std::string getname() const {
      return name; }
    // 获取地址
    std::string getaddress() const {
      return address; }
private:
    // 名字
    std::string name;
    // 地址
    std::string address;
};

// 辅助函数
std::istream &read(std::istream &is, Person &item);
std::ostream &print(std::ostream &os, const Person &item);

int main()
{
     
    Person p("xiao");

    return 0;
}

7.51


/**
 * const char * == string
 * int != vector
 */

7.52

#include 
#include 

using namespace std;

struct Sales_data {
     
    std::string bookNo;
    unsigned units_sold = 10;
    double revenue = 20;
};
// 没有类内初始值 这条，在Ｃ++14中已经废止

int main()
{
     
                    // 初始化列表转换成Sales_data
    Sales_data item = {
     "xi", 1, 2};

    cout << item.bookNo << item.units_sold << item.revenue << endl;

    return 0;
}

7.53


class Debug {
     
public:
    constexpr Debug(bool b = true) : hw(b), io(b), other(b) {
      }
    constexpr Debug(bool h, bool i, bool o) : hw(h), io(i), other(o) {
      }

    constexpr bool any() {
      return hw || io || other; }
    void set_io(bool b) {
      io = b; }
    void set_hw(bool b) {
      hw = b; }
    void set_other(bool b) {
      other = b; }
private:
    // 硬件错误
    bool hw;
    // io 错误
    bool io;
    // 其他错误
    bool other;
};

int main()
{
     
    Debug d;

    d.set_io(false);
}

7.54



/**
 * c++11 中 constexpr 的成员函数 隐式const 不能修改
 * c++14 行
 */

7.55



/**
 * string 不是
 */

7.56


/**
 * static 声明的成员
 * 全局作用域 可以是不完全类型 可以当默认实参
 * 类的静态成员与类本身直接相关, 而不是与类的各个对象保持关联
 */

7.57.cc

#include "Account.h"

void Account::rate(double newRate)
{
     
    interestRate = newRate;
}

double Account::initRate()
{
     
    return 1.0;
}

// 定义 static 数据成员
double Account::interestRate = initRate();

7.57.h

#ifndef ACCOUNT_H
#define ACCOUNT_H

#include 

class Account {
     
public:
    Account() = default;
    Account(std::string s, double d) : owner(s), amount(d) {
      }
    // 计算数量
    double calculate() {
      return amount += amount * interestRate;}
    // 输出利率
    static double rate() {
      return interestRate; }
    // 更新利率
    static void rate(double);
private:
    // 所有者
    std::string owner;
    // 数量
    double amount = 0;
    // 利率
    static double interestRate;
    static double initRate();
};
#endif

7.58



/**
 * rate 不是常量  double Example::rate = 6.5;
 * vec 不是常量  vector Example::vec(vecSize);
 */

你可能感兴趣的:(C++,Primer(第五版),c++)

c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python 开发语言
基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
C++菜鸟教程 - 从入门到精通第二节 DreamByte c++
一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
C++ lambda闭包消除类成员变量 barbyQAQ c++c++java 算法
原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题（第三大题：完善程序代码） mmz1207 c++csp
最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
《 C++ 修炼全景指南：九》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南 c++算法 stl
摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
20个新手学习c++必会的程序输出*三角形、杨辉三角等（附代码） X_StarX c++学习算法大学生开发语言数据结构
示例1:HelloWorld#includeusingnamespacestd;intmain(){coutusingnamespacestd;intmain(){inta=5;intb=10;intsum=a+b;coutusingnamespacestd;intfactorial(intn){if(nusingnamespacestd;voidprintFibonacci(intn){intt
C++八股 Petrichorzncu 八股总结 c++开发语言
这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】汉子萌萌哒 CCF noi 算法数据结构 c++
一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
《 C++ 修炼全景指南：十》自平衡的艺术：深入了解 AVL 树的核心原理与实现 Lenyiin C++修炼全景指南技术指南 c++数据结构 stl
摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
c++ opencv4.3 sift匹配图像处理大大大大大牛啊图像处理 opencv实战代码讲解 opencv sift c++opencv4 特征点
c++opencv4.3sift匹配main.cppintmain(){vectorkeypoints1,keypoints2;Matimg1,img2,descriptors1,descriptors2;intnumF
《 C++ 修炼全景指南：四》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表 Lenyiin 技术指南 C++修炼全景指南 c++list 链表 stl
本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
c++ 内存处理函数 heeheeai c++开发语言
在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
【c++基础概念深度理解——堆和栈的区别，并实现堆溢出和栈溢出】 XWWW668899 C++基本概念 c++c语言开发语言青少年编程
文章目录概要技术名词解释栈溢出和堆溢出小结概要学习C++语言，避免不了要好好理解一下堆（Heap）和栈（Stack），有助于更好地管理内存，以及如何写出一段程序“成功实现”堆溢出和栈溢出。技术名词解释理解东西最快的方式是根据自己目前能理解的词语去关联新的概念，不断的纠正，向正确的深度理解靠近，当无限接近的时候也就理解了想要理解的概念。我们经常说堆栈，把这两个名词放到一起。其实，堆是堆，栈是栈，两种
C++常见知识掌握 nfgo c++开发语言
1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
metaRTC5.0 API编程指南(一) metaRTC metaRTC c++c语言 webrtc
概述metaRTC5.0版本API进行了重构，本篇文章将介绍webrtc传输调用流程和例子。metaRTC5.0版本提供了C++和纯C两种接口。纯C接口YangPeerConnection头文件:include/yangrtc/YangPeerConnection.htypedefstruct{void*conn;YangAVInfo*avinfo;YangStreamConfigstreamco
sublime个人设置 bawangtianzun sublime text 编辑器
如何拥有jiangly蒋老师同款编译器(sublimec++配置竞赛向）_哔哩哔哩_bilibiliSublimeText4的安装教程（新手竞赛向）-知乎(zhihu.com)创建文件自动保存为c++打开SublimeText软件。转到"Tools"（工具）>"Developer"（开发者）>"NewPlugin"（新建插件）。在打开的新文件中，粘贴以下代码：importsublimeimport
Rust是否会取代C/C++？Rust与C/C++的较量 AI与编程之窗源码编译与开发 rust c语言 c++内存安全并发编程代码安全性能优化
目录引言第一部分：Rust语言的优势内存安全性并发性性能社区和生态系统的成长第二部分：C/C++语言的优势和地位历史积淀和成熟度广泛的库和工具支持性能优化和硬件控制丰富的行业应用社区和行业支持第三部分：挑战和阻碍学习曲线现有代码库的迁移成本生态系统和工具链的完善度社区和人才培养行业应用和推广法规和标准化第四部分：未来趋势和可能性行业趋势教育和人才培养兼容和共存行业标准化企业支持和应用开源社区和生态
python可以制作大型游戏_python能做游戏吗-python能开发游戏吗靖dede python可以制作大型游戏
python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
Python开发游戏？也太好用了吧七步编程工具 Github python python 游戏开发语言
程序员宝藏库：https://gitee.com/sharetech_lee/CS-Books-Store当然可以啦！现在日常能够用到和想到的场景，绝大多数都可以用Python实现。效果怎么样暂且不提，但是得益于丰富的第三方工具包，的确让Python能够很容易处理各种各样的场景。对于游戏开发也是这样，如果真的要想商业化，Python在游戏开发方面肯定没办法和C++相提并论，但是如果用于日常学习和自
Go编程语言前景怎么样？参加培训好就业吗 QFdongdong
Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
OpenCV图像处理技术（Python）——入门森屿_ opencv
©FuXianjun.AllRightsReserved.OpenCV入门图像作为人类感知世界的视觉基础，是人类获取信息、表达信息的重要手段，OpenCV作为一个开源的计算机视觉库，它包括几百个易用的图像成像和视觉函数，既可以用于学术研究，也可用于工业邻域，它于1999年由因特尔的GaryBradski启动，OpenCV库主要由C和C++语言编写，它可以在多个操作系统上运行。1.1图像处理基本操作
linux gcc 格式,Linux下gcc与gdb简介神奇的战士 linux gcc 格式
gcc编译器可以将C、C++等语言源程序、汇编程序编译、链接成可执行程序。gdb是GNU开发的一个Unix/Linux下强大的程序调试工具。linux下没有后缀名的概念。但gcc根据文件的后缀来区别输入文件的类别：.cC语言源代码文件.a由目标文件构成的库文件.C、.cc、.cppC++源码文件.h头文件.i经过预处理之后的C语言文件.ii经过预处理之后的C++文件.o编译后的目标文件.s汇编源码
浅谈openresty 爱编码的钓鱼佬 nginx openresty 运维
熟悉了nginx后再来看openresty，不得不说openresty是比较优秀的。对nginx和openresty的历史等在这此就不介绍了。首先对标nginx，自然有优劣一、开发难度nginx：毫无疑问nginx的开发难度比较高，需要扎实的c/c++基础，而且还需要对nginx源码比较熟悉，开发效率慢，比如实现一个类似echo的功能，至少要上百行代码。而openresty只需要一句ngx.say
Lua 与 C#交互 z2014z lua c#开发语言
Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
Java【泛型】 SkyrimCitadelValinor Java基础 java
Java泛型的概述不同类的数据如果封装方法相同，不必为每一种类单独定义一个类，只需定义一个泛型类，减少类的声明，提高编程效率。通过准确定义泛型类，可避免对象类型转换时产生的错误。泛型又提供了一种类型安全检测机制，只有数据类型相匹配的变量才能正常的赋值，否则编译器就不通过。Java中的泛型与C++类模板的作用相同，但是编译方式不同，Java泛型类只会生成一部分目标代码，牺牲运行速度，而C++的类模板
解读Servlet原理篇二---GenericServlet与HttpServlet 周凡杨 java HttpServlet 源理 GenericService 源码
在上一篇《解读Servlet原理篇一》中提到，要实现javax.servlet.Servlet接口（即写自己的Servlet应用），你可以写一个继承自javax.servlet.GenericServletr的generic Servlet ，也可以写一个继承自java.servlet.http.HttpServlet的HTTP Servlet（这就是为什么我们自定义的Servlet通常是exte
MySQL性能优化 bijian1013 数据库 mysql
性能优化是通过某些有效的方法来提高MySQL的运行速度，减少占用的磁盘空间。性能优化包含很多方面，例如优化查询速度，优化更新速度和优化MySQL服务器等。本文介绍方法的主要有： a.优化查询 b.优化数据库结构
ThreadPool定时重试 dai_lm java ThreadPool thread timer timertask
项目需要当某事件触发时，执行http请求任务，失败时需要有重试机制，并根据失败次数的增加，重试间隔也相应增加，任务可能并发。由于是耗时任务，首先考虑的就是用线程来实现，并且为了节约资源，因而选择线程池。为了解决不定间隔的重试，选择Timer和TimerTask来完成 package threadpool; public class ThreadPoolTest {
Oracle 查看数据库的连接情况周凡杨 sql oracle 连接
首先要说的是，不同版本数据库提供的系统表会有不同，你可以根据数据字典查看该版本数据库所提供的表。 select * from dict where table_name like '%SESSION%'; 就可以查出一些表，然后根据这些表就可以获得会话信息 select sid,serial#,status,username,schemaname,osuser,terminal,ma
类的继承朱辉辉33 java
类的继承可以提高代码的重用行，减少冗余代码；还能提高代码的扩展性。Java继承的关键字是extends 格式:public class 类名（子类）extends 类名（父类）{ } 子类可以继承到父类所有的属性和普通方法，但不能继承构造方法。且子类可以直接使用父类的public和 protected属性，但要使用private属性仍需通过调用。子类的方法可以重写，但必须和父类的返回值类
android 悬浮窗特效肆无忌惮_ android
最近在开发项目的时候需要做一个悬浮层的动画，类似于支付宝掉钱动画。但是区别在于，需求是浮出一个窗口，之后边缩放边位移至屏幕右下角标签处。效果图如下：一开始考虑用自定义View来做。后来发现开线程让其移动很卡，ListView+动画也没法精确定位到目标点。后来想利用Dialog的dismiss动画来完成。自定义一个Dialog后，在styl
hadoop伪分布式搭建林鹤霄 hadoop
要修改4个文件 1: vim hadoop-env.sh 第九行 2: vim core-site.xml <configuration> &n
gdb调试命令 aigo gdb
原文：http://blog.csdn.net/hanchaoman/article/details/5517362 一、GDB常用命令简介 r run 运行.程序还没有运行前使用 c cuntinue
Socket编程的HelloWorld实例 alleni123 socket
public class Client { public static void main(String[] args) { Client c=new Client(); c.receiveMessage(); } public void receiveMessage(){ Socket s=null; BufferedRea
线程同步和异步百合不是茶线程同步异步
多线程和同步 : 如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B依言执行，再将结果给A；A再继续操作。所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法多线程和异步:多线程可以做不同的事情,涉及到线程通知 &
JSP中文乱码分析 bijian1013 java jsp 中文乱码
在JSP的开发过程中，经常出现中文乱码的问题。首先了解一下Java中文问题的由来： Java的内核和class文件是基于unicode的，这使Java程序具有良好的跨平台性，但也带来了一些中文乱码问题的麻烦。原因主要有两方面，
js实现页面跳转重定向的几种方式 bijian1013 JavaScript 重定向
js实现页面跳转重定向有如下几种方式：一.window.location.href <script language="javascript"type="text/javascript"> window.location.href="http://www.baidu.c
【Struts2三】Struts2 Action转发类型 bit1129 struts2
在【Struts2一】 Struts Hello World http://bit1129.iteye.com/blog/2109365中配置了一个简单的Action，配置如下 <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configurat
【HBase十一】Java API操作HBase bit1129 hbase
Admin类的主要方法注释： 1. 创建表 /** * Creates a new table. Synchronous operation. * * @param desc table descriptor for table * @throws IllegalArgumentException if the table name is res
nginx gzip ronin47 nginx gzip
Nginx GZip 压缩 Nginx GZip 模块文档详见：http://wiki.nginx.org/HttpGzipModule 常用配置片段如下： gzip on; gzip_comp_level 2; # 压缩比例，比例越大，压缩时间越长。默认是1 gzip_types text/css text/javascript; # 哪些文件可以被压缩 gzip_disable &q
java-7.微软亚院之编程判断俩个链表是否相交给出俩个单向链表的头指针，比如 h1 ， h2 ，判断这俩个链表是否相交 bylijinnan java
public class LinkListTest { /** * we deal with two main missions: * * A. * 1.we create two joined-List(both have no loop) * 2.whether list1 and list2 join * 3.print the join
Spring源码学习-JdbcTemplate batchUpdate批量操作 bylijinnan java spring
Spring JdbcTemplate的batch操作最后还是利用了JDBC提供的方法，Spring只是做了一下改造和封装 JDBC的batch操作： String sql = "INSERT INTO CUSTOMER " + "(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";
[JWFD开源工作流]大规模拓扑矩阵存储结构最新进展 comsci 工作流
生成和创建类已经完成,构造一个100万个元素的矩阵模型,存储空间只有11M大,请大家参考我在博客园上面的文档"构造下一代工作流存储结构的尝试",更加相信的设计和代码将陆续推出......... 竞争对手的能力也很强.......,我相信..你们一定能够先于我们推出大规模拓扑扫描和分析系统的....
base64编码和url编码 cuityang base64 url
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.io.StringWriter; import java.io.UnsupportedEncodingException;
web应用集群Session保持 dalan_123 session
关于使用 memcached 或redis 存储 session ，以及使用 terracotta 服务器共享。建议使用 redis，不仅仅因为它可以将缓存的内容持久化，还因为它支持的单个对象比较大，而且数据类型丰富，不只是缓存 session，还可以做其他用途，一举几得啊。1、使用 filter 方法存储这种方法比较推荐，因为它的服务器使用范围比较多，不仅限于tomcat ，而且实现的原理比较简
Yii 框架里数据库操作详解-[增加、查询、更新、删除的方法 'AR模式'] dcj3sjt126com 数据库
public function getMinLimit () { $sql = "..."; $result = yii::app()->db->createCo
solr StatsComponent（聚合统计） eksliang solr聚合查询 solr stats
StatsComponent 转载请出自出处：http://eksliang.iteye.com/blog/2169134 http://eksliang.iteye.com/ 一、概述 Solr可以利用StatsComponent 实现数据库的聚合统计查询，也就是min、max、avg、count、sum的功能二、参数
百度一道面试题 greemranqq 位运算百度面试寻找奇数算法 bitmap 算法
那天看朋友提了一个百度面试的题目：怎么找出{1,1,2,3,3,4,4,4,5,5,5,5} 找出出现次数为奇数的数字. 我这里复制的是原话，当然顺序是不一定的，很多拿到题目第一反应就是用map,当然可以解决，但是效率不高。还有人觉得应该用算法xxx,我是没想到用啥算法好...！还有觉得应该先排序... 还有觉
Spring之在开发中使用SpringJDBC ihuning spring
在实际开发中使用SpringJDBC有两种方式： 1. 在Dao中添加属性JdbcTemplate并用Spring注入； JdbcTemplate类被设计成为线程安全的，所以可以在IOC 容器中声明它的单个实例，并将这个实例注入到所有的 DAO 实例中。JdbcTemplate也利用了Java 1.5 的特定(自动装箱，泛型，可变长度
JSON API 1.0 核心开发者自述 | 你所不知道的那些技术细节 justjavac json
2013年5月，Yehuda Katz 完成了JSON API(英文，中文) 技术规范的初稿。事情就发生在 RailsConf 之后，在那次会议上他和 Steve Klabnik 就 JSON 雏形的技术细节相聊甚欢。在沟通单一 Rails 服务器库—— ActiveModel::Serializers 和单一 JavaScript 客户端库——&
网站项目建设流程概述 macroli 工作
一.概念网站项目管理就是根据特定的规范、在预算范围内、按时完成的网站开发任务。二.需求分析项目立项　　我们接到客户的业务咨询，经过双方不断的接洽和了解，并通过基本的可行性讨论够，初步达成制作协议，这时就需要将项目立项。较好的做法是成立一个专门的项目小组，小组成员包括：项目经理，网页设计，程序员，测试员，编辑/文档等必须人员。项目实行项目经理制。客户的需求说明书　　第一步是需
AngularJs 三目运算表达式判断 qiaolevip 每天进步一点点学习永无止境众观千象 AngularJS
事件回顾：由于需要修改同一个模板，里面包含2个不同的内容，第一个里面使用的时间差和第二个里面名称不一样，其他过滤器，内容都大同小异。希望杜绝If这样比较傻的来判断if-show or not，继续追究其源码。 var b = "{{", a = "}}"; this.startSymbol = function(a) {
Spark算子：统计RDD分区中的元素及数量 superlxw1234 spark spark算子 Spark RDD分区元素
关键字：Spark算子、Spark RDD分区、Spark RDD分区元素数量 Spark RDD是被分区的，在生成RDD时候，一般可以指定分区的数量，如果不指定分区数量，当RDD从集合创建时候，则默认为该程序所分配到的资源的CPU核数，如果是从HDFS文件创建，默认为文件的Block数。可以利用RDD的mapPartitionsWithInd
Spring 3.2.x将于2016年12月31日停止支持 wiselyman Spring 3
Spring 团队公布在2016年12月31日停止对Spring Framework 3.2.x（包含tomcat 6.x）的支持。在此之前spring团队将持续发布3.2.x的维护版本。请大家及时准备及时升级到Spring
fis纯前端解决方案fis-pure zccst JavaScript
作者：zccst FIS通过插件扩展可以完美的支持模块化的前端开发方案，我们通过FIS的二次封装能力，封装了一个功能完备的纯前端模块化方案pure。 1，fis-pure的安装 $ fis install -g fis-pure $ pure -v 0.1.4 2，下载demo到本地 git clone https://github.com/hefangshi/f

C++ Primer(第五版) 第七章练习答案

C++ Primer(第五版) 第七章练习答案

目录

7.1

7.2

7.3

7.4

7.5

7.6

7.7

7.8

7.9

7.10

7.11

7.12

7.13

7.14

7.15

7.16

7.17

7.18

7.19

7.20

7.21

7.22

7.23

7.24

7.25

7.26

7.27

7.28

7.29

7.30

7.31

7.32

7.33

7.34

7.35

7.36

7.37

7.38

7.39

7.40.cc

7.40.h

7.41.cc

7.41.h

7.42

7.43

7.44

7.45

7.46

7.47

7.48

7.49

7.50

7.51

7.52

7.53

7.54

7.55

7.56

7.57.cc

7.57.h

7.58

你可能感兴趣的:(C++,Primer(第五版),c++)