c++学习笔记(7) 面向对象思想
面向对象思想：
1.string类：
C字符串：将字符串看作以‘/0’结尾的字符数组
string类： 处理字符串
2. 使用string类对象：
// 字符串初始化
string s1 = "Welcome to c++";
string s2("welcome to c++"); //构造方法，更高效 字符串追加函数 append()
字符串赋值函数assign()
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;
int main(int argc, char *argv[])
{
// append()函数
string s1("Welcome"); // 使用string类的构造方法初始化一个字符串
s1.append(" to c++"); // 直接追加
cout <<"s1 is: " << s1 << endl;
string s2("Welcome");
s2.append(" to C and c++", 5); // 将" to c and c++"的前五个字符追加到s2后面
cout << "s2 is: " << s2 << endl;
string s3("Welcome");
s3.append(3, 'G'); // 将字符'G'赋值为”GGG“追加到s3的后面
cout << "s3 is: " << s3 << endl;
// assign函数
string s4("Welcome");
s4.assign("Dollars"); // 给s4重新赋值
cout << "s4 is: " << s4 << endl;
string s5("Welcome");
s5.assign(5, 'F'); // 将”FFFFF“赋值给s5
cout << "s5 is: " << s5 << endl;
}
结果：
3. 函数
at(index) 返回索引值处的字符
clear() 清空一个字符串
bool empty()
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;
int main(int argc, char *argv[])
{
string s1("Welcome"); // 使用string类的构造方法初始化一个字符串
cout << s1.at(3) << endl;
cout << s1.erase(2, 3); // 从s1[2]处擦除3个字符 welcome-->weme
s1.clear();
cout << s1.empty() << endl;
return 0;
}
函数
length() 长度
size() 大小
capacity() 存储空间
c_str() 返回一个C字符串
compare() 返回值-1，1，0
substr() : substr(index, n)-->从index起始的n个字符 substr(index) 返回从index起始到末尾的字符串
find() 字符串搜索函数：
find(ch): 返回ch第一次出现的位置
find(sunstr) 子串出现的位置
find(ch, index) 返回从index位置起，ch出现的位置
find(substr, index)
insert(index, s) index位置， s子串
insert(index, n, ch) index位置， n个字符
replace()
5. 数字，字符串 相互转化
1. atoi(), atof(), 将字符串转化为 int 和 float
2. itoa(int n, char [], 2/8/10/16) 将数字转化为字符串
3. <sstream>头文件
stringstream类，提供的接口可以使我们像处理输入输出流一样来处理字符串
code:
#include <iostream>
#include <string>
#include <iomanip>
#include <sstream> // 将数字转化为字符串
using namespace std;
int main(int argc, char *argv[])
{
stringstream ss; // stringstream类，提供的接口可以使我们像处理输入输出流一样；来处理字符串
ss << 3.1245;
string s1 = ss.str();
cout << s1 << endl;
cout << s1.erase(2, 2) << endl; // 3.1245-->3.45
ss << 98.45667;
string s2 = ss.str();
cout << s2.append("Welcome") << endl; // 98.45667Welcome
return 0;
}
结果：
6. 字符串分割：
使用stringstream类来完成
#include <iostream>
#include <string>
#include <iomanip>
#include <sstream> // 将数字转化为字符串
using namespace std;
int main(int argc, char *argv[])
{
string text("Programing is very fun"); // 将每一个单词提取出来
stringstream ss(text); // stringstream类，提供的接口可以使我们像处理输入输出流一样；来处理字符串
cout << "The word in text are: " << endl;
string word;
while(!ss.eof())
{
ss >> word;
cout << word << endl;
}
return 0;
}
结果：
7.字符串替换的实现：
将字符串s中的oldSubStr替换为newStr
代码：
#include <iostream>
#include <string>
#include <iomanip>
#include <sstream> // 将数字转化为字符串
using namespace std;
bool replaceString(string&, string&, string&);
int main(int argc, char *argv[])
{
string ss, old_string, new_string;
cin >> ss >> old_string >> new_string;
bool isReplaced = replaceString(ss, old_string, new_string);
if(isReplaced)
{
cout << ss << endl;
}
else
{
cout << "No match";
}
return 0;
}
bool replaceString(string& s, string& oldSubStr, string& newSubStr)
{
bool isreplaced = false;
int current_position = 0;
while(current_position<s.length())
{
int position = s.find(oldSubStr, current_position);
if(position==string::npos)
{
return isreplaced;
}
else
{
s.replace(position, oldSubStr.length(), newSubStr); // 从current_position开始，替换的子串长度，新的子串
current_position = position + newSubStr.length(); // 更新current_position
isreplaced = true;
}
}
return isreplaced;
}
对象作为函数的参数：
值传递引用传递都是允许的：
对象参数采用值传递，实际上是将对象的内容复制给函数参数
以引用传递的方式：函数的参数实际上是需要传递的对象的一个别名
推荐使用引用传递，因为值传递需要额外的时间和空间
创建对象的回数组：
Circle circleArray[10];
circleArray是一个对象数组，会调用无参构造函数初始化
对象数组例子：
circle.h
// 关于类的定义
#ifndef CIRCLE_H
#define CIRCLE_H
class Circle
{
private:
double radius;
public:
// 定义数据域
//double radius;
// 构建函数
Circle();
// 构建函数
Circle(double);
// 定义函数
double getArea();
// define accessor
double getRadius();
// define mutator
void setRadius(double);
} ;
#endif
circle.cpp
// 类的实现
#include "E:\back_up\code\c_plus_code\chapter10\external_file\circle.h"
Circle::Circle()
{
radius = 1.0;
}
Circle::Circle(double new_radius)
{
radius = new_radius;
}
double Circle::getArea()
{
return 3.14*radius*radius;
}
double Circle::getRadius()
{
return radius;
}
void Circle::setRadius(double new_radius)
{
radius = new_radius;
}
main.cpp
#include <iostream>
#include <iomanip>
#include "E:\back_up\code\c_plus_code\chapter10\external_file\circle.h"
#include "E:\back_up\code\c_plus_code\chapter10\external_file\loan.h"
using namespace std;
const int SIZE = 10;
double sumCircle(Circle [], int);
void printCircle(Circle [], int);
int main(int argc, char *argv[])
{
Circle circle_array[SIZE];
for(int i=0; i<SIZE; i++)
{
circle_array[i].setRadius(i+5);
}
printCircle(circle_array, SIZE);
return 0;
}
double sumCircle(Circle circleArray[], int size)
{
double sumArea = 0;
for(int i=0; i<size; i++)
{
sumArea += circleArray[i].getArea();
}
return sumArea;
}
void printCircle(Circle circleArray[], int size)
{
cout << setw(25) << left << "Radius" << setw(8) << "Area" << endl;
for(int i=0; i<size; i++)
{
cout << setw(25) << left << circleArray[i].getRadius() << setw(8) << circleArray[i].getArea() << endl;
}
cout << "-----------------------------------------";
cout << "The total area of circles is " << sumCircle(circleArray, size) << endl;
}
8.实例成员和静态成员
概念： 实例变量和静态变量的区别：
实例变量： 在类的不同对象中是相互独立，互不影响的， 如Circle类中的radius
静态变量(类变量)：在类的不同对象中是共享的，如在circle中添加静态变量numberOfObjects表示实例化的对象的个数 // 初始化
实例函数：
静态函数：
修饰符static
区别： 在类中，实例函数，实例变量从属于对象，只有创建对象后，才能通过特定的对象进行访问。
静态函数和静态变量可以通过任意的类对象来访问，也可以直接通过类名访问
注意与匿名类的区别 cout << Circle().radius() cout << Circle(5).radius()这是匿名类
cout << Circle::number_of_object 以及Circle::getObjectNumber()是通过类名直接调用
例子程序： 注意程序中静态变量和静态函数的使用
circle.h
// 关于类的定义
#ifndef CIRCLE_H
#define CIRCLE_H
class Circle
{
private:
double radius;
static int number_of_obj; // 静态变量 类变量
public:
// 定义数据域
//double radius;
// 构建函数
Circle();
// 构建函数
Circle(double);
// 定义函数
double getArea();
// define accessor
double getRadius();
// define mutator
void setRadius(double);
// 静态函数
static int getObjectNumber();
} ;
#endif
circle.cpp
// 类的实现
#include "E:\back_up\code\c_plus_code\chapter10\external_file\circle.h"
int Circle::number_of_obj = 0; // 注意初始化的位置在这里 静态变量
Circle::Circle()
{
radius = 1.0;
number_of_obj++; // 实例化对象时 ++
}
Circle::Circle(double new_radius)
{
radius = new_radius;
number_of_obj++; // ++
}
double Circle::getArea()
{
return 3.14*radius*radius;
}
double Circle::getRadius()
{
return radius;
}
void Circle::setRadius(double new_radius)
{
radius = new_radius;
}
int Circle::getObjectNumber()
{
return number_of_obj;
} main.cpp
#include <iostream>
#include <iomanip>
#include "E:\back_up\code\c_plus_code\chapter10\external_file\circle.h"
#include "E:\back_up\code\c_plus_code\chapter10\external_file\loan.h"
using namespace std;
int main(int argc, char *argv[])
{
cout << "Created object number is " << Circle::getObjectNumber() << endl;
Circle circle1;
cout << "circle1 radius is " << circle1.getRadius() << endl;
cout << "circle1 areais " << circle1.getArea() << endl;
Circle circle2(5);
cout << "circle2 radius is " << circle2.getRadius() << endl;
cout << "circle2 areais " << circle2.getArea() << endl;
cout << "Created object number is " << Circle::getObjectNumber() << endl;
cout << "Created object number is " << circle1.getObjectNumber() << endl;
cout << "Created object number is " << circle2.getObjectNumber() << endl;
circle1.setRadius(10);
cout << "circle1 radius is " << circle1.getRadius() << endl;
cout << "circle1 areais " << circle1.getArea() << endl;
cout << "Created object number is " << Circle::getObjectNumber() << endl;
return 0;
}
结果：
建议使用类名访问静态函数和静态变量
只读成员函数
在成员函数后面加关键字const,这样相当于告诉编译器该成员函数不会改变数据域
只有实例才能被定义为只读函数
一般访问器函数被定义只读函数
9.从对象的角度考虑
BMI指数获取
重点： 类的定义，实现（具体）
定义实例变量，实例函数，静态变量，静态函数
定义只读函数
调用
code:
bmi.h文件：
#ifndef BMI_H
#define BMI_H
#include <string>
using namespace std;
class BMI
{
private:
string user_name;
int user_age;
double user_weight;
double user_height;
static int current_user_num; // 静态变量
public:
// constructor function
BMI();
BMI(string& new_name, int new_age, double new_weight, double new_height);
// define accessor 只读函数
string getName() const;
int getAge() const;
double getWeight() const;
double getHeight() const;
// define mutator
void setName(string& new_new_name);
void setAge(int new_new_age);
void setHeight(double new_new_height);
void setWeight(double new_new_weight);
// function general
double getBMI() const;
string getStatus() const;
static int getCurrentUserNum(); // 只有实例方法才能被定义为只读函数
};
#endif
bmi.cpp文件
#include "C:\Users\28491\Desktop\code\hello\external_file\bmi.h"
#include <string>
using namespace std;
int BMI::current_user_num = 0;
BMI::BMI()
{
user_name = "None";
user_age = 0;
user_height = 0.0;
user_weight = 0.0;
current_user_num++;
}
BMI::BMI(string& new_name, int new_age, double new_weight, double new_height)
{
user_name = new_name;
user_age = new_age;
user_weight = new_weight;
user_height = new_height;
current_user_num++;
}
// define accessor
string BMI::getName() const
{
return user_name;
}
int BMI::getAge() const
{
return user_age;
}
double BMI::getWeight() const
{
return user_weight;
}
double BMI::getHeight() const
{
return user_height;
}
// define mutator
void BMI::setName(string& new_new_name)
{
user_name = new_new_name;
}
void BMI::setAge(int new_new_age)
{
user_age = new_new_age;
}
void BMI::setWeight(double new_new_weight)
{
user_weight = new_new_weight;
}
void BMI::setHeight(double new_new_height)
{
user_height = new_new_height;
}
double BMI::getBMI() const
{
const double KILOGRAM_PER_POUND = 0.45359237;
const double METERS_PER_INCH = 0.0254;
double bmi = user_weight * KILOGRAM_PER_POUND / ((user_height * METERS_PER_INCH) * (user_height * METERS_PER_INCH));
return bmi;
}
string BMI::getStatus() const
{
double bmi = getBMI();
if(bmi<18.5)
return "Under_weight";
else if(bmi<25)
return "Normal";
else if(bmi<30)
return "Overweight";
else
return "Obesity";
}
int BMI::getCurrentUserNum()
{
return current_user_num;
}
main.cpp
#include <iostream>
#include <ctime>
#include <cmath>
#include <string>
#include "C:\Users\28491\Desktop\code\hello\external_file\bmi.h"
using namespace std;
int main(int argc, char *argv[])
{
string myname("zhangjun");
string hisname("wangwang");
BMI bmi_1(myname, 23, 120, 170);
cout << bmi_1.getName() << " is " << bmi_1.getAge() << " years old "
<< " and height is " << bmi_1.getHeight() << " and weight is "
<< bmi_1.getWeight() << endl;
cout << bmi_1.getName() << " BMI is " << bmi_1.getBMI() << " and status is "
<< bmi_1.getStatus() << endl;
cout << "Current user number is " << BMI::getCurrentUserNum() << endl;
BMI bmi_2;
bmi_2.setName(hisname);
bmi_2.setAge(28);
bmi_2.setHeight(180);
bmi_2.setWeight(100);
cout << bmi_2.getName() << " is " << bmi_2.getAge() << " years old "
<< " and height is " << bmi_2.getHeight() << " and weight is "
<< bmi_2.getWeight() << endl;
cout << bmi_2.getName() << " BMI is " << bmi_2.getBMI() << " and status is "
<< bmi_2.getStatus() << endl;;
cout << "Current user number is " << BMI::getCurrentUserNum() << endl;
//cout << "Bmi_1 name is " << bmi_1.getName() << endl;
//cout << "Bmi_1 age is " << bmi_1.getAge() << endl;
//cout << "Bmi_1 weight is " << bmi_1.getWeight() << endl;
//cout << "Bmi_1 height is " << bmi_1.getHeight() << endl;
//cout << "Current user is " << BMI::getCurrentUserNum() << endl;
return 0;
}
对象的合成：一个对对象可以包含另一个对象
实例研究： stack of integers类
栈（stack）: 是一个 “后进先出” 的数据结构
应用： 编译器用栈处理函数的调用，用一个栈保存被调用函数的参数和局部变量。当一个函数调用另一个函数时，新函数的参数和局部变量被压入栈中。当一个函数完成工作，返回调用者时，它占用的空间将从栈中释放掉。
stackofintegers.h
#ifndef STACK_H
#define STACK_H
class StackOfIntegers
{
private:
int size; // 栈的大小
int element[100];
public:
StackOfIntegers(); // 无参数构造函数
bool isEmpty() const; // 只读函数
int peek(); // 返回栈的第一个值
void push(int val); //入栈
int pop(); // 出栈
int getSize() const; // 返回栈的大小
};
#endif
stackofintegers..cpp
#include "C:\Users\28491\Desktop\code\hello\external_file\stackofintegers.h"
StackOfIntegers::StackOfIntegers()
{
size = 0;
}
bool StackOfIntegers::isEmpty() const
{
return size == 0;
}
int StackOfIntegers::peek()
{
return element[size-1];
}
void StackOfIntegers::push(int val) // pop and push 函数的实现
{
element[size++] = val;
}
int StackOfIntegers::pop() // 不是只读函数，对private做出了修改
{
return element[--size];
}
int StackOfIntegers::getSize() const
{
return size;
}
main.cpp
#include <iostream>
#include <ctime>
#include <cmath>
#include <string>
#include "C:\Users\28491\Desktop\code\hello\external_file\stackofintegers.h"
using namespace std;
int main(int argc, char *argv[])
{
StackOfIntegers stack;
for(int i=0; i<15; i++)
{
stack.push(i);
if(i==8)
{
cout << "The first element in stack is " << stack.peek() << endl;
}
}
cout << "Stack Size is " << stack.getSize() << endl;
cout << "Pop a number " << stack.pop() << endl;
return 0;
}
