静态友元常量成员
静态 友元 常量 成员
学习类中的一些特殊的成员，掌握他们的使用以及特点
一、静态成员
1、知识点
void fun()
{
static int a=10;//只会创建一次，第二次调用的时候就不执行了，但是a已经变成11了
a++;
cout<<a<<endl;
}
int main()
{
fun();//11
fun();//12
}
int a;==>声明
int a=10;==>初始化：在定义的时候赋值
赋值：在声明完之后，用“="给标识符赋值
1.静态成员指的是在c++类中声明成员时，可以加上static关键字，这样声明的成员叫静态成员，静态成员分为静态数据成员和静态函数成员两种
2、静态数据成员定义
class node
{
public:
static int id;//静态数据成员定义
}
int node::id=10;//静态数据成员必须在类外初始化
3、静态数据成员的特点
1.类中静态数据成员，所有对象都共享该数据，只有一份内存在内存中
2.类中的静态数据成员，必须要在类外初始化，因为他不属于对象，属于类，对象存在或者不存在，这个静态数据成员都是存在的，而且静态数据成员的声明周期是：程序开始就存在(主函数运行之前)，直到程序结束才被释放(无论是什么属性)
3.类中的静态数据成员，可以在类中被重新赋值(必须要在类外初始化之后才能再在类中赋值），可以被普通函数访问，如果该成员是公有属性，那么就还可以在类外被对象自己访问，或者通过类名访问
访问方式：类名：：静态数据
class A
{
public:
A()
{
cout<<"A构造"<<endl;
}
}
class person
{
static A* ss
static int num;
public:
static int sum;//静态数据成员
void setnum(int num)//给私有属性提供的公有属性接口
{
this->num = num;
}
int getnum()
{
return num;
}
person()
{
sum = 10;//这是赋值操作
num = 20;
}
};
int person::sum = 0;//类外初始化操作
int person::num = 0;
A* person::ss=new A;
//静态数据成员不能在类中初始化，必须要在类外初始化
//类型 类名：：静态成员=值
int main()
{
person p;//实例化对象
cout << p.sum << endl;
cout << p.getnum() << endl;
person p1;
p1.setnum(99);
cout << p.getnum() << endl;
cout << p1.getnum() << endl;
//类中的静态数据成员，所有的对象都共用这一个成员，这个静态数据成员只有一份内存在内存中
getchar();
getchar();
return 0;
}
node::id;
node n; n.id;
4、静态函数成员定义
class node
{
public:
static void fun(){}//类中定义
static void fun1()；//类中声明
}
void node::fun1(){}//在类外定义
5、静态函数成员的特点
class person
{
static int sum;
public:
static int getsum()
{
return sum;
}
}
int person::sum=10;
int main()
{
cout<<person::getsum()<<endl;//10
}
1.类中的静态函数成员，这个函数同样也不属于对象，而是属于类的，所以这个函数中不能操作类中的普通数据成员和普通函数成员。因为这些普通成员时必须要有对象的时候才会被建立，而静态函数不用对象也能调用
2.访问和静态数据成员一样
3.在这个静态函数成员中，不能访问这个类的普通成员，因为那些普通成员时需要有对象才会创建的，但是静态函数成员没有对象也能使用。可以在这个静态函数中使用局部变量，形参，静态数据成员
4.一般静态函数成员是用来操作静态数据成员的，在这个函数中，我们可以操作的数据是不属于对象的数据
6、单例模式
1.现在对于设计模式，没有太过详细去讲，把这个单例模式理解为一个套路，在特定的情况下使用
2.单例模式是一种常用的软件设计模式。通过单例模式可以保证系统中，应用该模式的类只有一个实例对象
单例模式的类中提供私有下的构造函数(默认，拷贝构造就够了)
包含一个本身这个类的私有的静态对象(指针或实例化的，几乎写的都是指针的)
提供一个静态的公有函数去创建或获取这个私有对象
在单例模式中的类中，把构造函数写在私有属性下面(默认，拷贝)
包含一个自身这个类类型的指针(静态)
#include<iostream>
using namespace std;
class Person
{
Person()
{
cout << "对象创建" << endl;
}
Person(const Person&p){}//拷贝构造
//这两个函数在私有属性下面，不能创建对象访问
static Person* person;//通过创建一个静态的指针对象，来访问
public:
static Person* getperson()
{
return person;
}
void speak()
{
cout << "我是单例模式" << endl;
}
};
Person* Person::person = new Person;
//静态数据成员要在类外初始化
int main()
{
Person* p = Person::getperson();
//这一句得到了：person这个指针成员
p->speak();
delete p;
p = NULL;
getchar();
getchar();
return 0;
}
单例模式分为两种：
饿汉模式：在初始化的时候就实例化了对象
懒汉模式：在类中自己提供静态的函数来实例化对象(公有属性)
class person
{
person()
{
cout << "我是懒汉模式" << endl;
}
static person* stance;
public:
static person* getperson()
{
if (stance == NULL)
{
stance = new person;
}
return stance;
}
};
二、友元成员
1、知识点
1.类的特性之一就是封装，而友元就是c++为用户提供打破这种封装的手段，友元分为友元函数和友元对象
2、友元函数
1.友元函数只是一个函数，友元函数不是类的成员，通过类对象是无法访问的，但是在这个函数中有权通过访问类中的成员
2.友元函数，无论声明在类中的任意访问属性下都可以，不影响他的调用和访问
#include<iostream>
#include<string>
using namespace std;
class Person
{
int id;
string name;
public:
Person(int id, string name)
{
this->id = id;
this->name = name;
}
//声明友元函数
friend void fun();
friend void fun1(Person&p);
};
void fun()
{
Person p(1, "yunfei");
cout << p.id << endl;
cout << p.name << endl;
}
void fun1(Person&p)
{
cout << p.id << endl;
cout << p.name << endl;
}
int main()
{
Person p1(2, "feiyun");
fun();
fun1(p1);
getchar();
getchar();
return 0;
}
3、友元类
友元类是一个单独的类，只不过和友元函数一样，在类中声明了一个友元类，在这个友元类中同样也可以访问该类中的所有成员，在A类中声明B类为A类的友元类，那么在B类中就可以访问A类中所有成员
#include<iostream>
#include<string>
using namespace std;
class girlfriend
{
void sleep()
{
cout << "一起睡觉" << endl;
}
public:
void speak()
{
cout << "一起说话" << endl;
}
//声明友元类
friend class Boy;
//声明了之后，Boy这个类才可以访问girlfriend里的私有属性
};
class Boy
{
girlfriend* gf;//要有这个对象才能访问girlfriend这个类
public:
Boy(girlfriend*gf)//构造函数
{
this->gf = gf;
}
void sport()
{
gf->speak();
gf->sleep();//声明之后才能访问
}
~Boy()//析构函数
{
if (gf != NULL)
{
delete gf;
gf = NULL;
}
}
};
int main()
{
Boy b(new girlfriend);
b.sport();
getchar();
getchar();
return 0;
}
4、友元的特性
1.单方向：B是A的朋友，B可以访问A的数据，A不可以访问B的数据
2.不传递：A是B的朋友，B是C的朋友，A和C没有朋友关系
3.不继承：A是B的朋友，B是C的父亲，A和C没有关系
三、常量成员
1、知识点
1.常量成员，指的是在c++类中声明对象成员时可以加上const关键字，这样声明的成员叫常量成员，常量成员分为两类：
常量数据成员
常量函数成员
2、常量数据成员
//定义
class node
{
const int id;
}
//初始化
const int id=10;//不建议使用，有的版本可能不支持或者通过初始化列表的方式初始化
3、初始化列表的使用
#include<iostream>
#include<string>
using namespace std;
class node
{
//const int id = 10;
const int id;
int b;
public:
node():id(42),b(99)//初始化列表
{
b = 34;//最后b=34
}//先执行初始化列表，然后执行构造函数
int getid()
{
cout << b << endl;
return id;
}
};
int main()
{
node p;
cout << p.getid() << endl;
getchar();
getchar();
return 0;
}
4、初始化列表的特性
1.初始化列表也是实现类中成员数据的初始化的一种方式
2.一些特殊情况下，数据成员的初始化只能用初始化列表的方式给数据成员赋值，而不能在构造函数中直接赋值
3.初始化列表必须写在构造函数的定义后面
4.构造函数能对数据的初始化工作，初始化列表也可以，但是初始化列表能做的，构造函数不一定能做
5.初始化列表的初始化顺序是按照他们在类中出现的顺序来初始化的，而不是在初始化列表中写的顺序来初始化的
构造函数---无参构造，有参构造，拷贝构造
5、常量函数成员
1.定义
class node
{
int id=10;
public:
void fun()const
{
id=20;//报错
int a;
a=10;//可以执行
}
void fun1()const;//类内声明
}
void node::fun1()const//类外实现
{
}
//在这个函数中，不能修改类中的数据成员(静态数据可以)
2.特点
类中的常量函数成员，在这个函数中不能对自身变量进行修改，通过语法限定，只要是this指针所指向的所有数据都不可以被修改(静态数据可以改变)。可以用来帮助我们来限定自身来调用这个函数修改自身的数据
可以用来只读操作
6、常量对象
1.在对象实例化的时候在类名前面加上const修饰，该对象为常量对象，满足常量的操作，声明是必须初始化
2.该对象里面的所有数据都不能被修改，因此对象里面的普通成员函数不允许被调用，只允许调用常量函数成员
类中的函数可以写在类外，只需在类中声明即可
#include<iostream>
#include<string>
using namespace std;
class person
{
public:
person();
void fun();
};
person::person()
{
cout << "这是构造函数" << endl;
}
void person::fun()
{
cout << "这个是fun函数" << endl;
}
int main()
{
person p;
p.fun();
getchar();
getchar();
return 0;
}
类的分文件编写
在头文件写下新建，在.h文件下面写函数声明，alt键+enter键，可以定义函数
