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;
}

c++学习笔记(7) 面向对象思想

面向对象思想：

猜你喜欢