大蠢驴博客

好好学习,天天向上。

0%

第一章——开始

第一章——开始

1.1 编写一个简单的C++程序

1
2
3
4
int main() {

return 0;
}

1.2 初始输入输出

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
int main() {
std::cout << "这是标准输出\n" << "输出之后还可以继续输出"<< std::endl; // std::endl操纵符的一种
std::cerr << "这是标准错误" << std::endl;
std::clog << "这是C++定义的日志输出流" << std::endl;
int var_int;
double var_double;
std::cin >> var_int >> var_double; // 这是标准输入,输入之后可以继续输入

return 0;
}

1.3 注释简介

1
2
3
4
5
6
#include <iostream>
/*
* 这是一种注释的写法,这种写法没有嵌套一说
*/

// 这是另外一种注释的写法

1.4 控制流

1.4.1 while循环

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
int main() {
unsigned loop1 = 0;
while (++loop1 < 10) {
std::cout << "loop1现在等于" << loop1 << std::endl;
}

unsigned loop2 = 0;
do {
std::cout << "loop2现在等于" << loop2 << std::endl;
} while(++loop2 < 10);
}

1.4.2 for语句

1
2
3
4
5
6
#include <iostream>
int main() {
for (int loop = 0; loop < 10; loop++) {
std::cout << "loop1现在等于" << loop1 << std::endl;
}
}

1.4.3 输入数量不定的输入数据

1
2
3
4
5
6
7
8
9
10
#include <iostream>

int main() {
int sum = 0;
int read_in;
while (std::cin >> read_in) { // cin可以用作条件判断,判断是否已无法读入更多数据
sum += read_in;
}
std::cout << "加和为" << "sum" << std::endl;
}

1.4.4 if 语句

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>

int main() {
int read_in;
std::cin >> read_in;
if (read_in >= 100) {
std::cout << "当前read_in不小于100\n";
} else {
std::cout << "当前read_in小于100\n";
}
return 0;
}

1.5 类简介

这小节开始,就开始接触类设计了。这本书的写作思路是先让读者将类类型用起来,然后再逐渐教会读者如何自定义类类型。刚开始的Demo代码需要用到书本提供的Sales_item.h类,已经放在文章末尾,在编码时直接引用就好

1.5.1 Sales_item 类

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include "Sales_item.h"

int main() {
Sales_item book1; // 类型的含义为“数据以及可以在这个数据上可以进行的操作的集合”,一个具体的类就是一个“类型”
std::cin >> book1; // 类类型可以支持各种操作,包括输入输出,就看编程人员怎么定义(实现)这个类
Sales_item book2;
std::cin >> book2;

std::cout << book1 + book2 << std::endl; // 相加操作以及输出操作
return 0;
}

1.5.2 初始成员函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
#include "Sales_item.h"

int main() {
Sales_item item1, item2;
std::cin >> item1 >> item2;

if (item1.isbn() == item2.isbn()) { // 类可以实现成员函数
std::cout << item1 + item2 << std::endl;
return 0;
} else {
std::cerr << "序号必须一样" << std::endl;
return -1;
}
}

术语表

Sales_item.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/*
* This file contains code from "C++ Primer, Fifth Edition", by Stanley B.
* Lippman, Josee Lajoie, and Barbara E. Moo, and is covered under the
* copyright and warranty notices given in that book:
*
* "Copyright (c) 2013 by Objectwrite, Inc., Josee Lajoie, and Barbara E. Moo."
*
*
* "The authors and publisher have taken care in the preparation of this book,
* but make no expressed or implied warranty of any kind and assume no
* responsibility for errors or omissions. No liability is assumed for
* incidental or consequential damages in connection with or arising out of the
* use of the information or programs contained herein."
*
* Permission is granted for this code to be used for educational purposes in
* association with the book, given proper citation if and when posted or
* reproduced.Any commercial use of this code requires the explicit written
* permission of the publisher, Addison-Wesley Professional, a division of
* Pearson Education, Inc. Send your request for permission, stating clearly
* what code you would like to use, and in what specific way, to the following
* address:
*
* Pearson Education, Inc.
* Rights and Permissions Department
* One Lake Street
* Upper Saddle River, NJ 07458
* Fax: (201) 236-3290
*/

/* This file defines the Sales_item class used in chapter 1.
* The code used in this file will be explained in
* Chapter 7 (Classes) and Chapter 14 (Overloaded Operators)
* Readers shouldn't try to understand the code in this file
* until they have read those chapters.
*/

#ifndef SALESITEM_H
// we're here only if SALESITEM_H has not yet been defined
#define SALESITEM_H

// Definition of Sales_item class and related functions goes here
#include <iostream>
#include <string>

class Sales_item {
// these declarations are explained section 7.2.1, p. 270
// and in chapter 14, pages 557, 558, 561
friend std::istream& operator>>(std::istream&, Sales_item&);
friend std::ostream& operator<<(std::ostream&, const Sales_item&);
friend bool operator<(const Sales_item&, const Sales_item&);
friend bool
operator==(const Sales_item&, const Sales_item&);
public:
// constructors are explained in section 7.1.4, pages 262 - 265
// default constructor needed to initialize members of built-in type
Sales_item() = default;
Sales_item(const std::string &book): bookNo(book) { }
Sales_item(std::istream &is) { is >> *this; }
public:
// operations on Sales_item objects
// member binary operator: left-hand operand bound to implicit this pointer
Sales_item& operator+=(const Sales_item&);

// operations on Sales_item objects
std::string isbn() const { return bookNo; }
double avg_price() const;
// private members as before
private:
std::string bookNo; // implicitly initialized to the empty string
unsigned units_sold = 0; // explicitly initialized
double revenue = 0.0;
};

// used in chapter 10
inline
bool compareIsbn(const Sales_item &lhs, const Sales_item &rhs)
{ return lhs.isbn() == rhs.isbn(); }

// nonmember binary operator: must declare a parameter for each operand
Sales_item operator+(const Sales_item&, const Sales_item&);

inline bool
operator==(const Sales_item &lhs, const Sales_item &rhs)
{
// must be made a friend of Sales_item
return lhs.units_sold == rhs.units_sold &&
lhs.revenue == rhs.revenue &&
lhs.isbn() == rhs.isbn();
}

inline bool
operator!=(const Sales_item &lhs, const Sales_item &rhs)
{
return !(lhs == rhs); // != defined in terms of operator==
}

// assumes that both objects refer to the same ISBN
Sales_item& Sales_item::operator+=(const Sales_item& rhs)
{
units_sold += rhs.units_sold;
revenue += rhs.revenue;
return *this;
}

// assumes that both objects refer to the same ISBN
Sales_item
operator+(const Sales_item& lhs, const Sales_item& rhs)
{
Sales_item ret(lhs); // copy (|lhs|) into a local object that we'll return
ret += rhs; // add in the contents of (|rhs|)
return ret; // return (|ret|) by value
}

std::istream&
operator>>(std::istream& in, Sales_item& s)
{
double price;
in >> s.bookNo >> s.units_sold >> price;
// check that the inputs succeeded
if (in)
s.revenue = s.units_sold * price;
else
s = Sales_item(); // input failed: reset object to default state
return in;
}

std::ostream&
operator<<(std::ostream& out, const Sales_item& s)
{
out << s.isbn() << " " << s.units_sold << " "
<< s.revenue << " " << s.avg_price();
return out;
}

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