C++primer_calss类

最新推荐文章于 2024-06-30 20:23:11 发布
最新推荐文章于 2024-06-30 20:23:11 发布
阅读量69 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46919075/article/details/131711322
版权

df# 学习目标：
掌握类的基础内容

学习内容：

1.类的简介
2.自定义数据结构
3.定义抽象数据类型
4.访问控制与封装
5.类的其他特性
6.类的作用域
7.构造函数再探
8.类的静态成员

题目解析

1.20

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

int main()
{
	Sales_item sa;
	std::cin >> sa;
	std::cout << sa << std::endl;
}

1.21

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

int main()
{
	Sales_item sa1;
	Sales_item sa2;
	std::cin >> sa1 >> sa2;
	std::cout << sa1 + sa2 << std::endl;
}

1.22

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

int main()
{
	Sales_item sa1;
	Sales_item sum_sa2;
	std::cin >> sum_sa2;
	while (std::cin >> sa1)
		sum_sa2 += sa1;
	std::cout << sum_sa2 << std::endl;
}

1.23

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

int main()
{
    Sales_item currItem, valItem;
    if (std::cin >> currItem) {
        int cnt = 1;
        while (std::cin >> valItem) {
            if (valItem.isbn() == currItem.isbn())
                ++cnt;
            else {
                std::cout << currItem << " occurs " << cnt << " times "
                          << std::endl;
                currItem = valItem;
                cnt = 1;
            }
        }

        std::cout << currItem << " occurs " << cnt << " times " << std::endl;
    }
    return 0;
}

1.24
测试
…

2.39
“foo”后面接“int”是非法的(是否忘记了“;”?)
main”的返回类型应为“int”而非“foo”
return”: 无法从“int”转换为“foo”

2.40

struct foo {
	std::string ib;
	unsigned com = 0;
	double pre = 0.00;
};

2.41

#include <iostream>
#include <string>
#include "Sales_data.h"
int main()
{
	Sales_data data1, data2;
	double price = 0;
	std::cin >> data1.bookno >> data1.units_sold >> price;
	data1.revenue = data1.units_sold * price;
	std::cin >> data2.bookno >> data2.units_sold >> price;
	data2.revenue = data2.units_sold * price;
	if (data1.bookno == data2.bookno) {
		unsigned totalCnt = data1.units_sold + data2.units_sold;
		double totalRevenue = data1.revenue + data2.revenue;
		std::cout << data1.bookno << " " << totalCnt << " "
			<< totalRevenue << " ";
		if (totalRevenue != 0)
			std::cout << totalRevenue/totalCnt << std::endl;
		else
			std::cout << "没有售出书本" << std::endl;
		return 0;
	}
	else {
		std::cerr << "不是相同书目" << std::endl;
		return -1;
	}
}

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

using std::cin;

int main()
{
	Sales_data data1, data2;
	double price1 = 0;
	if (cin >> data1.bookno >> data1.units_sold >> price1)
		data1.revenue = data1.units_sold * price1;
	double price2 = 0;
	while (cin >> data2.bookno >> data2.units_sold >> price1)
	{
		data2.revenue = data2.units_sold * price1;
		if (data1.bookno == data2.bookno)
		{
			data1.units_sold += data2.units_sold;
			data1.revenue += data2.revenue;
		}
		else
		{
			std::cout << data1.bookno << " " << data1.units_sold << " "
				<< data1.revenue << " ";
			if (data1.units_sold != 0)
				std::cout << data1.revenue / data1.units_sold << std::endl;
			else
				std::cout << "无售出";

			data1.bookno = data2.bookno;
			data1.units_sold = data2.units_sold;
			data1.revenue = data2.revenue;
		}
	}
	std::cout << data1.bookno << " " << data1.units_sold << " "
		<< data1.revenue << " ";
	if (data1.units_sold != 0)
		std::cout << data1.revenue / data1.units_sold << std::endl;
	else
		std::cout << "无售出";

	return 0;
}

2.42

#pragma once
#ifndef SALES_DATA_H
#define SALES_DATA_H
#include <string>
struct Sales_data {
	std::string bookno;
	unsigned units_sold = 0;
	double revenue = 0.00;
};

#endif

与41题相似

7.1
见习题2.41

7.2

#pragma once
#ifndef SALES_DATA_H
#define SALES_DATA_H

#include <string>
#include <iostream>

struct Sales_data {
	std::string bookno;
	unsigned units_sold = 0;
	double revenue = 0.00;

	std::string isbn() const { return bookno; }
	Sales_data &combine(const Sales_data &);
};
Sales_data &Sales_data::combine(const Sales_data &rhs)
{
	units_sold += rhs.units_sold;
	revenue += rhs.revenue;
	return *this;
}

#endif

7.3

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

int main()
{
    Sales_data total;
    double totalPrice;

    if (std::cin >> total.bookNo >> total.units_sold >> totalPrice)
    {
        total.revenue = total.units_sold * totalPrice;

        Sales_data trans;
        double transPrice;
        while (std::cin >> trans.bookNo >> trans.units_sold >> transPrice)
        {
            trans.revenue = trans.units_sold * transPrice;

            if (total.isbn() == trans.isbn())
            {
                total.combine(trans);
            }
            else
            {
                std::cout << total.bookNo << " " << total.units_sold << " " << total.revenue << " ";
                if (total.units_sold != 0)
                    std::cout << total.revenue / total.units_sold << std::endl;
                else
                    std::cout << "(no sales)" << std::endl;

                total = trans;
            }
        }

        std::cout << total.bookNo << " " << total.units_sold << " " << total.revenue << " ";
        if (total.units_sold != 0)
            std::cout << total.revenue / total.units_sold << std::endl;
        else
            std::cout << "(no sales)" << std::endl;

        return 0;
    }
    else
    {
        std::cerr << "No data?!" << std::endl;
        return -1;  // indicate failure
    }
}

7.4

#pragma once
#ifndef PERSON_H
#define PERSON_H

#include <string>

struct Person {
	std::string name;
	std::string address;
};

#endif

7.5
使用const，只需读取成员函数的成员对象无需改变对象

#pragma once
#ifndef PERSON_H
#define PERSON_H

#include <string>

struct Person {
	std::string name;
	std::string address;

	std::string get_name() const { return name; }
	std::string get_address() const { return address; }
};

#endif

7.6

#pragma once
#ifndef SALES_DATA_H
#define SALES_DATA_H

#include <string>
#include <iostream>

struct Sales_data {
	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.00;

	std::string isbn() const { return bookNo; }
	Sales_data &combine(const Sales_data &);
	double avg_price() const;
};
double Sales_data::avg_price() const {
	if (units_sold)
		return revenue / units_sold;
	else
		return 0;
}
Sales_data &Sales_data::combine(const Sales_data &rhs)
{
	units_sold += rhs.units_sold;
	revenue += rhs.revenue;
	return *this;
}
std::istream &read(std::istream &is, Sales_data &item)
{
	double price = 0;
	is >> item.bookNo >> item.units_sold >> price;
	item.revenue = price * item.units_sold;
	return is;
}
std::ostream &print(std::ostream &os, const Sales_data &item)
{
	os << item.isbn() << " " << item.units_sold << " "
		<< item.revenue << " " << item.avg_price();
	return os;
}
Sales_data add(const Sales_data &lsh, const Sales_data &rhs)
{
	Sales_data sum = lsh;
	sum.combine(rhs);
		return sum;
}

#endif

7.7

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

int main()
{
    Sales_data total;
    double totalPrice;

    if (read(std::cin, total))
    {

        Sales_data trans;
       while (read(std::cin, trans))
        {

            if (total.isbn() == trans.isbn())
            {
                total.combine(trans);
            }
            else
            {
                print(std::cout, total);
                std::cout << std::endl;
                total = trans;
            }
        }

        print(std::cout, total);
        std::cout << std::endl;

        return 0;
    }
    else
    {
        std::cerr << "No data?!" << std::endl;
        return -1;  // indicate failure
    }
}

7.8
read的Sales_data参数会被修改，print不会

7.9

#pragma once
#ifndef PERSON_H
#define PERSON_H

#include <string>

struct Person {
	std::string name;
	std::string address;

	std::string get_name() const { return name; }
	std::string get_address() const { return address; }
};
std::istream &read(std::istream &is, Person &item)
{
	return is >> item.name >> item.address;
}
std::ostream &print(std::ostream &os, const Person &item)
{
	return os << item.name << " " << item.address;
}

#endif

7.10
输入data1和data2，判断条件是否为真

7.11

#pragma once
#ifndef SALES_DATA_H
#define SALES_DATA_H

#include <string>
#include <iostream>

struct Sales_data {
	Sales_data() = default;
	Sales_data(const std::string &s) : bookNo(s) { }
	Sales_data(const std::string &s, unsigned n, double p) :
		bookNo(s), units_sold(n), revenue(p*n) { }
	Sales_data(std::istream &);

	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.00;

	std::string isbn() const { return bookNo; }
	Sales_data &combine(const Sales_data &);
	double avg_price() const;
};
double Sales_data::avg_price() const {
	if (units_sold)
		return revenue / units_sold;
	else
		return 0;
}
Sales_data &Sales_data::combine(const Sales_data &rhs)
{
	units_sold += rhs.units_sold;
	revenue += rhs.revenue;
	return *this;
}
std::istream &read(std::istream &is, Sales_data &item)
{
	double price = 0;
	is >> item.bookNo >> item.units_sold >> price;
	item.revenue = price * item.units_sold;
	return is;
}
std::ostream &print(std::ostream &os, const Sales_data &item)
{
	os << item.isbn() << " " << item.units_sold << " "
		<< item.revenue << " " << item.avg_price();
	return os;
}
Sales_data add(const Sales_data &lsh, const Sales_data &rhs)
{
	Sales_data sum = lsh;
	sum.combine(rhs);
		return sum;
}

#endif

7.12

#pragma once
#ifndef SALES_DATA_H
#define SALES_DATA_H

#include <string>
#include <iostream>

struct Sales_data;

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


struct Sales_data 
{
	Sales_data() = default;
	Sales_data(const std::string &s) : bookNo(s) {}
	Sales_data(const std::string &s, unsigned n, double p) : bookNo(s), units_sold(n), revenue(p*n) {}
	Sales_data(std::istream &is) {read(is,*this); }

	std::string isbn() const { return bookNo; }
	Sales_data &combine(const Sales_data &);
	double avg_price() const;

	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.0;
};

Sales_data &Sales_data::combine(const Sales_data &rhs)
{
	units_sold += rhs.units_sold;
	revenue += rhs.revenue;
	return *this;
}

double Sales_data::avg_price() const {
	if (units_sold)
		return revenue / units_sold;
	else
		return 0;
}

std::istream &read(std::istream &is, Sales_data &item)
{
	double price = 0;
	is >> item.bookNo >> item.units_sold >> price;
	item.revenue = price * item.units_sold;
	return is;
}
std::ostream &print(std::ostream &os, const Sales_data &item)
{
	os << item.isbn() << " " << item.units_sold << " "
		<< item.revenue << " " << item.avg_price();
	return os;
}
Sales_data add(const Sales_data &lhs, const Sales_data &rhs)
{
	Sales_data sum = lhs;
	sum.combine(rhs);
		return sum;
}

#endif

7.13

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

int main()
{
    Sales_data total (std::cin);

    if (!total.isbn().empty())
    {

        Sales_data trans;
       while (read(std::cin, trans))
        {

            if (total.isbn() == trans.isbn())
            {
                total.combine(trans);
            }
            else
            {
                print(std::cout, total);
                std::cout << std::endl;
                total = trans;
            }
        }

        print(std::cout, total);
        std::cout << std::endl;
        return 0;
    }
    else
    {
        std::cerr << "No data?!" << std::endl;
        return -1;  // indicate failure
    }
}

7.14

	Sales_data() : bookNo(""), units_sold(0), revenue(0){}

7.15

#pragma once
#ifndef PERSON_H
#define PERSON_H

#include <string>

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

struct Person {

	Person() : name(" "), address(" "){}
	Person (const std::string &n, const std::string &a) : name(n), address(a){}
	Person(std::istream &is) { read(is, *this); }

	std::string name;
	std::string address;

	std::string get_name() const { return name; }
	std::string get_address() const { return address; }
};
std::istream &read(std::istream &is, Person &item)
{
	return is >> item.name >> item.address;
}
std::ostream &print(std::ostream &os, const Person &item)
{
	return os << item.name << item.address;
}

#endif

7.16
一个类可以包含0个或多个访问说明符，而且对于某个说明符能出现多少次也没有严格的限定
public成员定义类接口，private部分封装了类的实现部分。

7.17
使用struct关键字，则定义在第一个访问说明符之前的成员是public的，
相反，使用class关键字，则这些成员是private的。

7.18
含义：封装实现了类的接口和实现的分离
用处：1.确保用户代码不会无意间破坏封装对象的状态。2.被封装的类的具体实现细节可以随时改变，
而无须调整用户级别的代码。

7.19

struct Person {

public:
	Person() : name(" "), address(" "){}
	Person (const std::string &n, const std::string &a) : name(n), address(a){}
	Person(std::istream &is) { read(is, *this); }

	std::string get_name() const { return name; }
	std::string get_address() const { return address; }

private:
	std::string name;
	std::string address;
};

接口应该是公共的所以使用public，实现的部分比如数据不应该暴露在外所以使用private。

7.20
使其允许其他类或函数访问它的非公有成员
优点：
外部函数可以方便地使用类的成员，而不需要显示地给它们加上类名；
可以方便地访问所有非公有成员；
有时，对类的用户更容易读懂。
缺点：
减少封装和可维护性；
代码冗长，类内的声明，类外函数声明。

7.21

#pragma once
#ifndef SALES_DATA_H
#define SALES_DATA_H

#include <string>
#include <iostream>

struct Sales_data;

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


struct 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(const std::string &s) : bookNo(s) {}
	Sales_data(const std::string &s, unsigned n, double p) : bookNo(s), units_sold(n), revenue(p*n) {}
	Sales_data(std::istream &is) {read(is,*this); }

	std::string isbn() const { return bookNo; }
	Sales_data &combine(const Sales_data &);
	double avg_price() const;

private:
	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.0;
};

Sales_data &Sales_data::combine(const Sales_data &rhs)
{
	units_sold += rhs.units_sold;
	revenue += rhs.revenue;
	return *this;
}

double Sales_data::avg_price() const {
	if (units_sold)
		return revenue / units_sold;
	else
		return 0;
}

std::istream &read(std::istream &is, Sales_data &item)
{
	double price = 0;
	is >> item.bookNo >> item.units_sold >> price;
	item.revenue = price * item.units_sold;
	return is;
}
std::ostream &print(std::ostream &os, const Sales_data &item)
{
	os << item.isbn() << " " << item.units_sold << " "
		<< item.revenue << " " << item.avg_price();
	return os;
}
Sales_data add(const Sales_data &lhs, const Sales_data &rhs)
{
	Sales_data sum = lhs;
	sum.combine(rhs);
		return sum;
}

#endif

7.22

#pragma once
#ifndef PERSON_H
#define PERSON_H

#include <string>

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

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

public:
	Person() : name(" "), address(" "){}
	Person (const std::string &n, const std::string &a) : name(n), address(a){}
	Person(std::istream &is) { read(is, *this); }

	std::string get_name() const { return name; }
	std::string get_address() const { return address; }

private:
	std::string name;
	std::string address;
};
std::istream &read(std::istream &is, Person &item)
{
	return is >> item.name >> item.address;
}
std::ostream &print(std::ostream &os, const Person &item)
{
	return os << item.name << item.address;
}

#endif

7.23

#pragma once
#ifndef SCREEN_H
#define SCREEN_H

#include <iostream>
#include <string>

class Screen {
public:
	typedef std::string::size_type pos;
	Screen() = default;

	Screen(pos ht, pos wd, char c) : height(ht), width(wd), contents(ht * wd, c){}
	char get() const { return contents[cursor]; }
	inline char get(pos ht, pos wd) const;
	Screen &move(pos r, pos c);
private:
	pos cursor = 0;
	pos height = 0, width = 0;
	std::string contents;
};

inline Screen &Screen::move(pos r, pos c)
{
	pos row = r * width;
	cursor = row + c;
	return *this;
}

char Screen::get(pos r, pos c) const
{
	pos row = r * width;
	return contents[row + c];
}
#endif

7.24

Screen() = default;
Screen(pos ht, pos wd) : height(ht), width(wd){}
Screen(pos ht, pos wd, char c) : height(ht), width(wd), contents(ht * wd, c){}

7.25
能，Screen类中只有内置类型和string，这些能使用默认版本

7.26

//类外
inline double Sales_data::avg_price() const {
	if (units_sold)
		return revenue / units_sold;
	else
		return 0;
}
//或类内显式或隐式
inline double Sales_data::avg_price() const 
double Sales_data::avg_price() const

###补充关于const的相关记忆

int i = 0; const int ci = 0;  //int const ci = 0

int &g = i; const int &g = i;  //int const &g = i; // &后面应是标识符
int &cg = ci; const int &cg = ci;

int *p = &i; const int *p = &i; // int const *p = &i;
int *cp = &ci; const int *cp = &ci;

int *const cpp = &i; const  int *const cpp = &i; // int const *const cpp = &i; // *const后面应是标识符
int *const cpp = &ci; const int *const cpp = &ci;



int i = 0;
//顶层const,不能修改地址,本身是常量
int *const p1 = &i; //
const int ci = 42;
//底层const,不能修改地址和值,本身不是常量，指向的对象是常量
//拷出的对象要是底层const，拷入的对象能转换成底层const
const int *p2 = &ci;
const int &r = ci;

7.27

#pragma once
#ifndef SCREEN_H
#define SCREEN_H

#include <iostream>
#include <string>

class Screen {
public:
	typedef std::string::size_type pos;
	Screen &set(char);
	Screen &set(pos, pos, char);
	Screen() = default;

	Screen(pos ht, pos wd, char c) : height(ht), width(wd), contents(ht * wd, c){}
	char get() const { return contents[cursor]; }
	inline char get(pos ht, pos wd) const;
	Screen &move(pos r, pos c);
	Screen &display(std::ostream &os) { do_display(os); return *this; }
	const Screen &display(std::ostream &os) const { do_display(os); return *this; }

private:
	pos cursor = 0;
	pos height = 0, width = 0; 
	std::string contents;
	void do_display(std::ostream &os) const { os << contents; }
};

inline Screen &Screen::move(pos r, pos c)
{
	pos row = r * width;
	cursor = row + c;
	return *this;
}

char Screen::get(pos r, pos c) const
{
	pos row = r * width;
	return contents[row + c];
}
inline Screen &Screen::set(char c)
{
	contents[cursor] = c;
	return *this;
}
inline Screen &Screen::set(pos r, pos col, char ch)
{
	contents[r * width + col] = ch;
	return *this;
}

#endif

#include <string>
#include <iostream>
#include "SCREEN.H"

int main()
{
	Screen myScreen(5, 5, 'X');
	myScreen.move(4, 0).set('#').display(std::cout);
	std::cout << "\n";
	myScreen.display(std::cout);
	std::cout << "\n";

	return 0;
}

7.28

7.29

7.30

7.31

class X {
	Y *y = nullptr;

};

class Y {
	X x;

};

7.32

#ifndef SCREEN_H_
#define SCREEN_H_

#include <string>
#include <vector>

class Screen;

class Window_mgr
{
public:
    using ScreenIndex = std::vector<Screen>::size_type;
    void clear(ScreenIndex);
private:
    std::vector<Screen> screens;
};

class Screen 
{
friend void Window_mgr::clear(ScreenIndex);
public:
    using pos = std::string::size_type;

    Screen() = default;
    Screen(pos ht, pos wd):height(ht), width(wd){ }
    Screen(pos ht, pos wd, char c):height(ht), width(wd), contents(ht*wd, c){ }

    char get() const { return contents[cursor]; }
    char get(pos r, pos c) const { return contents[r*width+c]; }
    Screen &move(pos r, pos c);
    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:
    pos cursor = 0;
    pos height = 0, width = 0;
    std::string contents;
    void do_display(std::ostream &os) const {os << contents;}
};



inline Screen &Screen::move(pos r, pos c)
{
	pos row = r * width;
	cursor = row + c;
	return *this;
}

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

inline Screen &Screen::set(pos r, pos col, char c)
{
	contents[r*width + col] = c;
	return *this;
}

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

#endif

7.33

#pragma once
#ifndef SCREEN_H
#define SCREEN_H

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


class Screen {
	friend void Window_mgr::clear(ScreenIndex);


public:
	typedef std::string::size_type pos;
	Screen &set(char);
	Screen &set(pos, pos, char);
	Screen() = default;

	Screen(pos ht, pos wd, char c) : height(ht), width(wd), contents(ht *wd, c) {}
	char get() const { return contents[cursor]; }
	inline char get(pos ht, pos wd) const;
	Screen &move(pos r, pos c);
	Screen &display(std::ostream &os) { do_display(os); return *this; }
	const Screen &display(std::ostream &os) const { do_display(os); return *this; }
	pos size() const;


private:
	pos cursor = 0;
	pos height = 0, width = 0;
	std::string contents;
	void do_display(std::ostream &os) const { os << contents; };
};

inline Screen &Screen::move(pos r, pos c)
{
	pos row = r * width;
	cursor = row + c;
	return *this;
}

char Screen::get(pos r, pos c) const
{
	pos row = r * width;
	return contents[row + c];
}
inline Screen &Screen::set(char c)
{
	contents[cursor] = c;
	return *this;
}
inline Screen &Screen::set(pos r, pos col, char ch)
{
	contents[r * width + col] = ch;
	return *this;
}
Screen::pos Screen::size() const
{
	return height * width;
}

#endif

7.34
会报错，内部声明是有顺序的

7.35

#include <string>

typedef std::string Type;
Type initVal(); // 全局的
class Exercise {
public:
    typedef double Type;
    Type setVal(Type); // 两者都是类内的
    Type initVal(); // 类内的
private:
    int val;
};
Type Exercise::setVal(Type parm) { // 前者是全局，后者是类内的
    val = parm + initVal(); // 类内的
    return val;
}
//改
//Exercise::Type Exercise::setVal(Type parm) { // 前者是全局，后者是类内的
//    val = parm + initVal();
//    return val;
//}

7.36
改变rem，base的顺序

int base,rem;

7.37

Sales_data first_item(cin);   // use Sales_data(std::istream &is) ; its value are up to your input.

int main() {
  Sales_data next;  // use Sales_data(std::string s = ""); bookNo = "", cnt = 0, revenue = 0.0
  Sales_data last("9-999-99999-9"); // use Sales_data(std::string s = ""); bookNo = "9-999-99999-9", cnt = 0, revenue = 0.0
}

7.38

Sales_data(std::istream &is = std::cin) { read(is, *this); }

7.39
非法，两个以上默认构造函数，重载构造函数不明确

7.40

#pragma once
#ifndef BOOK_H
#define BOOK_H
#include <iostream>
#include <string>

class Book
{
public:
    Book(unsigned isbn, std::string const &name, std::string const &author, std::string const &pubdate)
        :isbn_(isbn), name_(name), author_(author), pubdate_(pubdate)
    { }

    explicit Book(std::istream &in)
    {
        in >> isbn_ >> name_ >> author_ >> pubdate_;
    }

private:
    unsigned isbn_;
    std::string name_;
    std::string author_;
    std::string pubdate_;
};


#endif

7.41

#pragma once
#ifndef SALES_DATA_H
#define SALES_DATA_H

#include <string>
#include <iostream>

struct Sales_data;

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


struct 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(const std::string &s, unsigned n, double p) : bookNo(s), units_sold(n), revenue(p *n) { std::cout << "s,n,p" << std::endl; }
	Sales_data(const std::string &s) : Sales_data(s, 0, 0) { std::cout << "Sales_data(s)" << std::endl; }
	Sales_data() : Sales_data("", 0, 0) { std::cout << "Sales()" << std::endl; }
	Sales_data(std::istream &is) : Sales_data() {read(is,*this); }

	std::string isbn() const { return bookNo; }
	Sales_data &combine(const Sales_data &);
	inline double avg_price() const;

private:
	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.0;
};

Sales_data &Sales_data::combine(const Sales_data &rhs)
{
	units_sold += rhs.units_sold;
	revenue += rhs.revenue;
	return *this;
}

inline double Sales_data::avg_price() const {
	if (units_sold)
		return revenue / units_sold;
	else
		return 0;
}

std::istream &read(std::istream &is, Sales_data &item)
{
	double price = 0;
	is >> item.bookNo >> item.units_sold >> price;
	item.revenue = price * item.units_sold;
	return is;
}
std::ostream &print(std::ostream &os, const Sales_data &item)
{
	os << item.isbn() << " " << item.units_sold << " "
		<< item.revenue << " " << item.avg_price();
	return os;
}
Sales_data add(const Sales_data &lhs, const Sales_data &rhs)
{
	Sales_data sum = lhs;
	sum.combine(rhs);
		return sum;
}

#endif

7.42

Book(unsigned isbn, std::string const &name, std::string const &author, std::string const &pubdate)
        :isbn_(isbn), name_(name), author_(author), pubdate_(pubdate)
    { }

可以作为委托构造函数，因为处理的信息量足够

7.43

#include <string>

class NoDefault {
public:
	NoDefault(int i) {};
};

	struct C {
	public:
		C() : de(0) {};

	private:
		NoDefault de;
};

7.44
合法

7.45
合法

7.46
（a）不正确，没有构造函数时，编译器会生成一个默认构造函数
（b）不正确，也有参数的默认构造函数其参数是默认值
（c）不正确，默认构造函数有时很重要
（d）不正确，当类没有显式构造函数时，编译器才会生成一个合成的默认构造函数

7.47
不是，这样方便我们进行转换
优点：
防止隐式转换的产生；
可以只用作初始化。
缺点：
只有个单个参数的构造函数才有意义。

7.48
不是explicit的：
string类型
Sales_data临时量类型
Sales_data临时量类型

是explicit
string类型
Sales_data临时量类型
Sales_data临时量类型

7.49

7.50

explicit Person(std::istream &is) { read(is, *this); }

7.51
这里直接调用参数是vector的get的一个实参数值会报错，因为函数不知道这个数是容器大小还是容器的第一个值

int get(const std::vector<int> &);
    get(12);

这里形参换成string就不会

int get2(const std::string &);
    get2("ds");

7.52
聚合类要求没有类内初始值，程序应该改成

struct Sales_data {
    std::string bookNo;
    unsigned units_sold;
    double revenue;
};

7.53

#ifndef DEBUG_EX53_
#define DEBUG_EX53_

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;
	bool io;
	bool other;
};

#endif

7.54
constexpr函数是隐式的const。

7.55
不是，有一个string类型的数据成员所以不是字面值常量类。

7.56
类的静态成员是和类绑定的成员，但是不和类的对象绑定
优点：可以直接调整对象，数据成员非法的地方静态成员可以替代
区别：数据成员的作用域在类内，静态成员的作用域在类外

7.57

#ifndef ACCOUNT_EX57_H_
#define ACCOUNT_EX57_H_

#include <string>

class Account
{
public:
	void calculate() {amount += amount * interestRate;}
	static double rate(){return interestRate;}
	static void rate(double newRate){ interestRate = newRate;}
private:
	std::string owner;
	double amount;
	static double interestRate;
	static double initRate(){return 4.0;}
};
double Account::interestRate = initRate();


#endif

7.58

//example.h
#include <vector>
class Example {
public:
    static double rate = 6.5; //成员必须为常量
    static const int vecSize = 20;
    static std::vector<double> vec(vecSize); //vecSize是在类外声明的
};
//example.c
double Example::rate;
std::vector<double> Example::vec; //静态成员只能定义一次

改

//example.h
#include <vector>
class Example {
public:
    static double rate;
    static const int vecSize = 20;
    static std::vector<double> vec;
};
//example.c
double Example::rate = 6.5;
std::vector<double> Example::vec(vecSize);
习题集
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++类(Class)总结
weixin_68123569的博客
08-24 2684
C++类(Class)总结
C++ primer 5th练习代码
03-08
在你提供的“《C++primer 5th》练习代码”压缩包中，你可能会看到以下类型的代码实践： - 变量声明和运算符的使用：比如简单的计算和条件判断。 - 函数的定义和调用：包括函数参数的传递，返回值的处理等。 - 类的...
C++ Primer_1 书店程序
Ai_King的博客
09-11 1611
C++ Primer_1 书店程序
C++ Primer 第七章 Screen类与Window_mgr类
TPON的博客
05-13 420
C++ Primer 第七章 Screen类与Window_mgr类
C++ Primer中的Sales_data类(完整可运行版本)
m0_37545861的博客
06-28 1056
Sales_data.h #ifndef SALES_DATA_H #define SALES_DATA_H #include <string> #include <iostream> class Sales_data{ // 为Sales_data的非成员函数所做的友元声明 friend Sales_data add(const Sales_data &lhs, const Sales_data &rhs ); friend std::istream &amp
C++_Primer_1
亓天大圣是猴子吗的博客
05-05 140
第一章简单介绍了： 1.输入输出 2.注释简介 3.控制流 4.类简介 5.书店程序（贯穿全书，以此作为例子讲解全部C++知识） ====================================== 1.iostream（istream&&ostream) #include <iostream> int main() { int a; ...
《C++ Primer》第一章的 Sales_item.h
weixin_44597588的博客
05-27 1864
在第一章敲到 #include "Sales_item.h"时，编译出现错误，原因是Sales_item类不是标准库自带的，需要自己写好再使用头文件（#include "Sales_item.h）访问，作者已经写好了这个类，名为Sales_item.h，如下： #ifndef SALESITEM_H #define SALESITEM_H #include <iostream> #include <string> class Sales_item{ public: Sa
C++ Primer——Sales_item.h头文件源码及相关问题解决
热门推荐
seineo
01-25 1万+
在C++ Primer 第五版中有一个小练习要将网站上的头文件源码“拷贝到工作目录中”，首先，似乎并没有那个网站，源码也是百度资源上找的。其次，拷贝到工作目录中，添加头文件有个小细节。 源码如下： #ifndef SALESITEM_H #define SALESITEM_H #include &amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;lt;string&amp;amp
C++ Primer 课后习题详解 | 12.1.1 shared_ptr 类
Linux猿
12-23 1226
C++ Primer 课后习题详解 | 12.1.1 shared_ptr 类
C++Primer Plus学习笔记
weixin_45068267的博客
04-08 1741
此博文是通过翻阅C++ Primer Plus中文第6版（2020），逐章学习记录笔记由此学习C++的基础特性和语法知识，有别于其它视频教学+代码+笔记的学习途径，更趋向传统的书籍+代码+笔记学习，Cpp第6版以C++11标准为主，学习C++基础编程绰绰有余.
C++ enum class枚举类
bulebin的博客
02-01 1万+
一、定义 枚举类型：是用户定义的若干枚举常量的集合，属于用户自定义的数据类型。 C++枚举包含两种：限定作用域枚举类型和不限定作用域枚举类型。 定义限定作用域的枚举类型的一般形式是使用enum class关键字。此类型也是我们本文要讲解的主题：枚举类。 eg： enum class open_modes{ input, output, append }; 二、使用 1、用法 对于枚举类，访问其成员需要遵循常规的作用域准则，并且成员在枚举类的作用域外是不可以被访问
C++Primer笔记
11-17
C++ Primer 笔记 本笔记基于 C++ Primer 的学习笔记，涵盖了友元函数、操作符重载、运算符重载、using 声明和引用等多个知识点。 友元函数 友元函数是一种特殊的函数，它可以访问类的私有成员。通过让函数成为类...
c++ primer附录文件和源代码.zip
12-15
3. **类与对象**：C++的核心是面向对象编程，需要理解类（class）的构造和析构，对象的创建与销毁，以及封装、继承和多态等概念。 4. **模板**：C++的模板允许我们编写泛型代码，可以应用于各种数据类型。包括函数...
C++ Primer 5th笔记2001
08-08
总的来说，《C++ Primer 5th》笔记涵盖了C++编程的基础，包括程序构造、控制流、类的概念和基本类型的使用，这些都是构建复杂C++应用程序的基础。通过深入理解和实践这些知识点，开发者可以逐步掌握C++这一强大且...
C语言中的基础指针操作
m0_73500130的博客
06-29 893
在C语言中，指针是一个非常重要的概念，它提供了直接访问内存地址的能力。指针变量用于存储内存地址，而不是数据值，在某种意义上和门牌号具有相似含义：指针是一个变量，其存储的是另一个变量的内存地址，这个内存地址唯一的标识，用于指向特定的内存位置。门牌号也是用来唯一标识一个具体的房屋或地址的，但指针的使用要复杂得多，涉及到内存的管理、指针的运算、野指针的避免等多个方面。在处理数组、字符串、动态内存分配以及函数参数传递等方面使得程序员们能够编写出更灵活、更高效的代码。
【C++】————string基础用法及部分函数底层实现
最新发布
bhbcdxb123的博客
06-30 1031
本文主要介绍STL容器之一 ---- string，在学习C++的过程中，我们要将C++视为一个语言联邦（摘录于Effective C++ 条款一）。如何理解这句话呢，我们学习C++，可将其分为四个板块；分别为C、Object-Oriented C++（面向对象的C++）、Template C++（模板）、STL。本文就介绍STL中的string；1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。
《C++ Primer Plus第五版》
风中的默默
06-26 936
连续分段空间,由一段一段的连续空间构成的，用一小块连续的内存空间map作为主控(不是STL的map容器)，里面的每一个元素都是一个指针，指向另一段连续性内存空间，称作缓冲区，默认使用 512 字节大小。假设我们定义一个双向链表，把链表上节点都定义成shared_ptr智能指针，当其中两个节点互相引用的时候，就会出现循环引用的现象。堆是我们通过new关键字来动态申请的内存空间，堆上分配的内存需要我们手动管理，堆是不连续的内存区域，以链表的形式分配的，如果我们没有正确释放堆上的内存可能会出现内存泄漏。
C语言-二级指针应用场景
gopher9511的博客
06-26 883
使用二级指针的主要目的是为了安全地管理和修改指针，避免悬挂指针问题。在函数内部，能够直接修改调用者的指针，使其指向 NULL，从而提升代码的健壮性。
关键路径——C语言（理论）
2302_80790488的博客
06-28 748
关键路径，是项目网络中从起始事件到终止事件的最长路径，决定了项目的最短完成时间。 关键路径中的任务没有任何可调整的余地，如果任何一个任务被延迟，整个项目的完成时间也会被延迟。
c++primer plus
08-24
- *3* [C++PrimerPlus知识点小结](https://blog.csdn.net/qq_34921856/article/details/83500754)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值