学习C++(七)

字符串string的使用

// string constructor
#include <iostream>
#include <string>
using namespace std;

int main ()
{
		string s0 ("Initial string");

		// constructors used in the same order as described above:
		string s1;//空
		/*复制*/
		string s2 (s0);  //Initial string         
		/*剪切字符串中间的某一部分*/
		string s3 (s0, 8, 3);//Initial str 
		/*剪切字符串的前面某一部分*/
		string s4 ("Another character sequence", 12);//Another char
        /*重复复制字符串*/
		string s5a (10, 'x');//xxxxxxxxxx
        /*用ASCII码来做字符串的初始化*/
		string s5b (10, 42);// **********
		/*用字符串的地址初始化*/
		string s6 (s0.begin(), s0.begin()+7);//Initial

		cout << "s1: " << s1 << "\ns2: " << s2 << "\ns3: " << s3;
		cout << "\ns4: " << s4 << "\ns5a: " << s5a << "\ns5b: " << s5b;
		cout << "\ns6: " << s6 << '\n';
		return 0;
}

字符串string的内部实现

//String.h
#ifndef STRING_H_
#define STRING_H_
#include <cstring>

class String{
private:
	char 	*m_data;
public:
    String(int data);
	String(const char* data);
	String(const String& rhs);
	~String();

	const char* data() const { return this->m_data; }
	
	int size() const { return strlen(this->m_data); }
};

#endif

#include "String.h"
#include <cstring>

String::String(const char* data)
{
	int len = 0;
	if(0 == data){
		len = 0;
	}else{
		len = strlen(data);
	}

	//申请空间
	this->m_data = new char[len + 1]();
	//拷贝
	strcpy(this->m_data, data);
	this->m_data[len] = '\0';
}

String::String(const String& rhs)
{
	int len = strlen(rhs.m_data);
	this->m_data = new char[len + 1]();
	strcpy(this->m_data, rhs.m_data);
	this->m_data[len] = '\0';
}

String::~String()
{
	if(0 != this->m_data){
		delete[] this->m_data;
		this->m_data = 0;
	}
}

#include "String.h"
#include <iostream>
using namespace std;

int main(void)
{
	String s1 = "hello";
	String s2("iotek");
	String s3 = String("XW1905");
	String* p_s = new String("yes");

	String s4 = s1;				//拷贝构造函数

	cout << "s1: " << s1.data() << endl;
	cout << "s2: " << s2.data() << endl;
	cout << "s3: " << s3.data() << endl;
	cout << "p_s: " << p_s->data() << endl;
	cout << "s4: " << s4.data() << endl;
	delete p_s;	
	return 0;
}

类中static的使用

#include <iostream>
using namespace std;

class Example{
public:
	int 			m_x;		    //4
	static 	int 	m_y;		//静态属性 4
public:

	Example(int x)//构造函数只初始化无static的属性
		:m_x(x)
	{
	
	}

	void display() const
	{
		cout << "m_x: " << this->m_x << ", m_y: " << this->m_y << endl;
	}

	static void func()//静态方法
	{
		cout << "func()" << endl;
		cout << m_y << endl;
	}

};

int Example::m_y = 88;		//静态属性的定义

int main(void)
{
  /*静态属性的存储不在类中*/
	cout << sizeof(Example) << endl;//4

	Example x(10);
	Example y(100);
	Example z(999);

	x.display();//m_x: 10, m_y: 88

  /*类中静态属性的修改 方法一：通过对象属性修改*/
	x.m_y = 888;
	y.display();//m_x:100, m_y:888

  /*类中静态属性的修改 方法二：通过类作用域修改*/
	Example::m_y = 8888;
	z.display();

  /*类中静态方法的访问 方法一：通过对象访问*/
	x.func();

  /*类中静态方法的访问 方法二：通过类作用域访问*/
	Example::func();

	return 0;
}

经典单例模式

#include <iostream>
#include <memory>
using namespace std;

class Signal{
private:
	Signal()
	{
		cout << "Signal" << endl;
	}
	/*①类中私有 保存唯一实例的指针*/
	static Signal* instance;
public:
	/*②提供唯一对象的访问接口*/
	static Signal* getInstance();   
};
/*③类中静态属性的定义*/
Signal* Signal::instance = 0;		  
/*④类中静态方法的定义*/
Signal* Signal::getInstance()
{
	if(0 == instance){
		instance = new Signal();
	}
	return instance;
}

int main(void)
{
	Signal *instance = Signal::getInstance();
	auto_ptr<Signal> p(instance);			//智能指针托管
	
	Signal *instance2 = Signal::getInstance();
	Signal *instance3 = Signal::getInstance();
	Signal *instance4 = Signal::getInstance();
	Signal *instance5 = Signal::getInstance();
	
	return 0;
}

运算符重载

+ 运算符重载例子

  定义一个Point类
  重载 + 运算符类把两个point相加

#include <iostream>
using namespace std;

class Point{
private:
	int 	x;
	int 	y;
public:
	Point(int x, int y)
		:x(x),
		y(y)
	{
	
	}

	int getX() const { return this->x; }
	int getY() const { return this->y; }

	void setX(int x) { this->x = x; }
	void setY(int y) { this->y = y; }

	void display() const
	{
		cout << "(" << this->x << ", " << this->y << ")" << endl;	
	}
};

const Point operator + (const Point& lhs, const Point& rhs)
{	
	int x = lhs.getX() + rhs.getX();
	int y = lhs.getY() + rhs.getY();
	return Point(x, y);
}

int main(void)
{
	Point point1(3, 4);
	point1.display();

	Point point2(5,6);
	point2.display();

	Point point3 = point1 + point2;		//Point = Point + Point
	                      //Point p3 = operator+(point1, point2);
	point3.display();

	return 0;
}