C++学习笔记day2

1.单例模式的作用与目的
作用：保证一个类仅有一个实例，并提供了一个访问它的全局访问点
目的：为了保证类的实例对象只有一个
主要解决：一个全局使用的类 频繁的创建于销毁
关键： 构造函数和拷贝构造私有化

2、实现方法
1.私有构造函数和拷贝构造函数   不让类的外部创建对象
2.静态类指针     在静态成员函数中实现只创建一个对象的逻辑
3.静态成员函数返回类指针  用来实例化(new)对象

c++中静态成员：
1.属于整个类 静态成员变量只存储一份供所有对象使用，所有同类型的对象共享静态变量
2.必须在类外单独初始化 而且只能全局进行 否则不会分配空间 编译报错
#include 
using namespace std;

class A
{
public:
   static int num;
};
//1.初始化之后，才会对变量分配空间 2.类外进行单独的初始化
int A::num = 10;

int main()
{
    //3.使用静态变量，可以直接只用 类::的方式 获取变量
   cout<
using namespace std;

class A
{
public:
   static int num;
   int age;
   A(int n):age(n){}
   static int getNum()
   {
     //静态成员函数没有this指针，就不能使用类中普通的成员变量
     //静态函数只能访问静态的成员变量
     //cout<age< 
 
5.2 单例模式实现方法 
*******************************one.h
#ifndef ONE_H
#define ONE_H

class One
{
    //1.私有构造和拷贝
    One();
    One(const One& other);
    //2.静态指针
    static One* instance;

    int num;
public:
    //3.静态函数：1.创建对象  2.返回静态指针
    //通过静态全局访问口  获取对象指针
    static One* getInstance();

    int getNum()
    {
        num++;
        return num;
    }
    void setNum(int n)
    {
        num = n;
    }

    ~One();
};

#endif // ONE_H

***************************cpp	
#include "one.h"
#include 

//cpp文件 进行初始化
One* One::instance = NULL;

One::One(){ num = 1;}
One::One(const One &other){}

One *One::getInstance()
{
    if(instance == NULL)
        instance = new One;
   return instance;
}

One::~One()
{
    if(instance != NULL)
        delete instance;
}

*******************************main
#include 
#include "one.h"
using namespace std;
/*
 * 设计模式之单例模式

1.单例模式的作用与目的
    作用：保证了一个类仅有一个实例，并提供了一个访问它的全局访问点
    目的：为了保证类的实例对象只有一个
    主要解决：一个全局使用的类 频繁的创建于销毁
    关键： 构造函数和拷贝构造私有化
2、实现方法
    1.私有构造函数和拷贝构造函数   不让类的外部创建对象
    2.静态类指针     在静态成员函数中实现只创建一个对象的逻辑
    3.静态成员函数返回类指针  用来实例化(new)对象
 * */
int main()
{
  One* o1 = One::getInstance();
  o1->setNum(10);
  One* o2 = One::getInstance();
  One* o3 = One::getInstance();

  cout<getNum()<getNum()<
 
六、重载（遮蔽） 
运算符重载：运算符重载本质是函数重载，函数名以运算符的形式来命名，调用函数也是通过运算符来调用
作用：如果类没有重载运算符，类的对象不能进行运算符的 *** 作

1、定义
1.重载：给运算符重新赋予新的含义，在类的内部定义的运算符重载和成员函数是一样的
2.重载方法：定义一个重载运算符的函数 在需要执行被重载的运算符时，系统会自动调用该函数；
3.重载运算符格式：
	函数类型 operator 运算符名称(形参列表) 
	bool     operator     ==   (const Person &s);	
4.运算符重载的参数个数由运算符本身决定，但是类型可以自定义 
5.由运算符的左值调用运算符的重载
6.如果类没有重载运算符，类的对象不能进行运算符的 *** 作
注意：可以将函数的重载定义成全局的，但是不方便 <<  >>
void operator+(const pereson  other)
{
}
person p;
person p2;
p.operotor+(p2);成员函数一样  普通的调用
p+p2;自动调用

运算符重载虽然对返回值类型和参数类型没有要求，但是我们依然不能随便定义；返回值类型和参数的类型一定要符合习惯才能让代码变得更优雅。
 
6.1 运算符重载（+ >= ==  与=  & ） 
****************代码示例1：+号的重载**************
#include 
using namespace std;

class Person
{
    int age;
public:
    Person(int age):age(age){}
    void show(){    cout=运算符**************
#include 
using namespace std;
 
class Person
{
public:
	int _age;
	Person(int age):_age(age)
	{
	}
	int operator >=(Person& other)
	{
    		if(this->age>other.age)
         		return 1;
    		else
         		return 0;
 	}
};

int main()
{
	Person per1(14);
	Person per2(6);
	cout << (per1 >= per2) << endl;
	return 0;
}
**************示例3：==运算符重载**************
#include
using namespace std;

class Person
{
private:
	int age;
public:
	Person(int a)
	{
		age = a;
	}
	bool operator==(const Person &s);	//==运算符的重载 
};
//this是运算符的左值，参数是运算符的右值
bool Person::operator==(const Person &s)
{
	if(this->age==s.age)
	{
		return true;
	}
	else 
	{
		return false;
	}
}

int main()
{
	Person p1(20);
	Person p2(20);
	if(p1==p2)//这里之所以能够使用==运算符，是因为Person重载了==运算符
	{
		cout<<"the age is equal!"<
using namespace std;

class Person
{
    int age;
    string name;
public:
    Person(int a):age(a)
    {
    }
    Person(string name,int a):name(name),age(a)
    {
    }
   bool operator == (Person& other);
   bool operator == (int a);
   bool operator == (string n);
};
bool Person::operator ==(Person& other)
{
       if(this->age == other.age)
           return true;
       else
           return false;
}
bool Person::operator ==(string n)
{
    if(this->name == n)
        return true;
    else
        return false;
}
bool Person::operator ==(int a)
{
    if(this->age == a)
        return true;
    else
        return false;
}

int main()
{
    Person p(10);
    Person p1(20);

   if(p == p1)//p.operator==(p1)
   {
       cout<<"equal"<
using namespace std;

class Person
{
    int age;
    string name;
public:
    Person(int a):age(a){
        cout<<"构造"<age = other.age;
    }
   void show(){
       cout
 
6.2  默认存在函数(5) 与 不可重载运算符（5） 
C++默认存在的函数
1）默认构造函数
2）默认拷贝构造函数
3）析构函数
4）默认=重载  
5）默认&重载   这是一个有争议的运算符重载。说它存在因为每个对象都能取地址；说它不存在没人会去重载取地址运算符。面试的时候就说它&是默认存在，知道就比不知道好。

不能重载的运算符 5个  
 ?:   sizeof()   . (成员运算符)  ::    .*  ->* (成员指针运算符)



示例7：&运算符
#include 
using namespace std;
 
class Person
{
public:
	int _age;
	Person(int age):_age(age)
	{
	}
	//以下的两个&重载函数，只能保留其一，因为不能构成函数的重载
	int* operator & ()
	{
		return &this->_age;
	}
	Person* operator&()
    	{
       	 	return this;
    	}
};
int main()
{
	Person per1(14);
	int *p = &per1;
	cout << p << endl;
	return 0;
}


++ -- 运算符重载
默认情况下为前缀形式 operator++(  )    前缀++p 
后缀形式需要添加一个int类型参数，参数无意义，
仅仅用于区分前缀和后缀形式  operator++(int a)  后缀p++
#include 
using namespace std;

class Person
{
private:
	int age;
public:
	Person(int age):age(age){}	
	Person& operator++()
	{
		cout<<"前缀形式"< 
总结 
这里对文章进行总结：
					
										


					

						
欢迎分享，转载请注明来源：内存溢出
原文地址: http://outofmemory.cn/langs/1499021.html