静态 友元 常量

学习类中的一些特殊的成员，掌握他们的使用以及特点

一、静态成员

1、知识点

一般在.cpp文件中，定义全局变量

int count=0;

在.h文件中声明这个全局变量——防止重复包含头文件时，多次定义全局变量

extern int count;

类的静态数据成员，在类的实现方法进行初始化（必须初始化）

public下的静态数据成员可以直接通过类名访问

void fun()
{
    static int a=10;//只会创建一次，第二次调用只会执行下面的a++
    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.静态数据成员的生命周期是：程序开始就存在(主函数运行之前)，直到程序结束才被释放(无论是什么属性)

4.类中的静态数据成员，可以在类中被重新赋值(必须要在类外初始化之后才能再在类中赋值），可以被普通函数访问

5.如果该成员是公有属性，那么就还可以在类外被对象自己访问，或者通过类名访问

访问方式：类名：：静态数据

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.单例模式的类中提供私有下的构造函数(默认，拷贝构造就够了)

3.包含一个本身这个类的私有的静态对象

4.提供一个静态的公有函数去创建或获取这个私有对象

在单例模式中的类中，把构造函数写在私有属性下面(默认，拷贝)

包含一个自身这个类类型的指针(静态)

#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++为用户提供打破这种封装的手段，友元分为友元函数和友元对象

/*
1.我们已经知道类具备封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员，程序中的其他函数是无法访问私有成员的。
2.非成员函数能够访问类中的公有成员，但是假如将数据成员都定义为公有的，这又破坏了隐藏的特性。
3.另外，应该看到在某些情况下，特别是在对某些成员函数多次调用时，由于参数传递，类型检查和安全性检查等都需要时间，而影响程序的运行效率。
*/

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没有关系

4.友元的作用在于提高程序的运行效率，但是他破坏了类的封装性和隐藏性，使得非成员函数能够访问类的私有成员。

三、常量成员

1、知识点

1.常量成员，指的是在c++类中声明对象成员时可以加上const关键字，这样声明的成员叫常量成员，常量成员分为两类：

常量数据成员

常量函数成员

2、常量数据成员

//定义
class node
{
    const int id; 
}
//初始化
const int id=10;//不建议使用，有的版本可能不支持或者通过初始化列表的方式初始化，从c11以上支持定义数据时初始化

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.该对象里面的所有数据都不能被修改，因此对象里面的普通成员函数不允许被调用，只允许调用常量函数成员

7.const引用

不是const引用，就不能对const变量进行引用

但是：const引用可以对非const变量进行引用

void play(Man &man) {
    man.play();
}
​
const Man man1;
play(man1);
//这是错误的
/*
原因：man1是const的不能被修改，而play()的形参是非const引用，所以man是可以被修改的，但是man1不能被修改所以错误
​
反过来，play()的形参是const引用，但是传入的参数可以是非const的
*/