c++关于静态、友元、常量成员的复习整理

一、静态成员

静态成员包含静态变量和静态函数。
静态成员的性质：
1、类中的静态数据成员，所有对象都共享这一个成员，这个静态数据成员只有一份存在于内存中
2、类中的静态函数成员，因为他不属于对象，所以在这个函数中只能操作类的静态数据，静态函数
3、类中的静态数据成员，不管共有私有都是在类外进行初始化
（类型 类名::静态成员=初始化值）
4、类中静态数据成员初始化，静态数据成员不属于对象，无法通过对象的操作进行初始化，它是属于类的
5、静态数据成员，可以被重新赋值，可以被普通函数访问

1、静态变量

静态成员变量是一种特殊的成员变量，它被关键字static修饰

class Student
{
private:
 char* m_name;
 int m_age;
public:
 static int m_total;
public:
 Student(const char* name,int age);
 void show();
 ~Student();
};
int Student::m_total = 0;//在类外初始化
Student::Student(const char* name,int age)
{
 cout << "带参构造" << endl;
     m_name = new char[strlen(name) + 1];
 strcpy(m_name, name);
 this->m_age = age;
 m_total++;
}
void Student::show()
{
 cout << m_name<< "\t" << m_age << "\t" << m_total << "\t" <<endl;
}
Student::~Student()
{
 cout << "析构" << endl;
 if (m_name!=NULL)
 {
 delete[]m_name;
 m_name = NULL;
 }
}
int main()
{
 Student stu1("小王",18);
 stu1.show();
  Student* stu2 = new Student("小孔", 18);
 stu2->show();
 
 system("pause");
 return 0;
}

当把静态变量设置为私有属性时，同样需要在共有属性中提供接口使用该静态成员变量。
static 成员变量的内存既不是在声明类时分配，也不是在创建对象时分配，而是在（类外）初始化时分配。因此，可以说没有在类外初始化的 static 成员变量不能使用。
static 成员变量不占用对象的内存，而是在所有对象之外开辟内存，即使不创建对象也可以访问。

2、静态函数

普通成员函数可以访问所有成员（包括成员变量和成员函数），静态成员函数只能访问静态成员。

class Student
{
private:
 char* m_name;
 int m_age;
public:
 static int m_total;
  static void Getsum();
public:
 Student(const char* name,int age);
 void show();
 ~Student();
};
int Student::m_total = 0;//在类外初始化
Student::Student(const char* name,int age)
{
 cout << "带参构造" << endl;
     m_name = new char[strlen(name) + 1];
 strcpy(m_name, name);
 this->m_age = age;
 m_total++;
}
void Student::Getsum()//静态函数的定义
{
 cout <<m_total<<endl;
}
void Student::show()
{
 cout << m_name<< "\t" << m_age << "\t" << m_total << "\t" <<endl;
}
Student::~Student()
{
 cout << "析构" << endl;
 if (m_name!=NULL)
 {
 delete[]m_name;
 m_name = NULL;
 }
}
int main()
{
 Student stu1("小王",18);
 stu1.show();
 stu1.Getsum();
  Student* stu2 = new Student("小孔", 18);
 stu2->show();
  stu2.Getsum();
 
 system("pause");
 return 0;
}

在C++中，静态成员函数的主要目的是访问静态成员，普通函数也可以直接访问静态成员。

二、常量成员

1、类中常量成员分为两种：常量数据成员和常量函数成员
2、类中的常量数据成员，必须要使用初始化列表的方式进行初始化 const int a;
3、类中的常量函数成员，这个函数不能对自身变量进行修改，这个是常量的特性 void fun() const {}
Ⅰ、受语法限定，只要是this指针所指向的所有数据，在这个函数里面都不可以改
Ⅱ、初始化之外的形参数据，临时变量，不属于this指针的数据都可以改
Ⅲ、根据语法，可以帮助我们来限定去修改自身的数据
4、对象被说明说常量对象时，这个对象只能调用常量数据成员函数
Ⅰ、这个对象里面的所有数据都是不可以被修改的
Ⅱ、可以对象里面的静态成员，因为静态成员不属于对象

1、常量成员变量

const 成员变量的用法和普通 const 变量的用法相似，只需要在声明时加上 const 关键字。想要对const成员变量初始化，应该借助构造函数的初始化来进行。

2、常量函数成员

函数开头的 const 用来修饰函数的返回值，表示返回值是 const 类型，也就是不能被修改
函数头部的结尾加上 const 表示常成员函数，这种函数只能读取成员变量的值，而不能修改成员变量的值

char* Student::getname()const
{
return m_name
}

三、友元成员

1、类的特点是封装，友元是C++为用户提供打破这中封装（数据隐藏）的手段
2、友元分为两种：友元函数，友元类
3、友元函数：是一个函数，这个函数不是对象的成员，对象是无法调用的，不管在哪里定义，但是这个函数有权调用类的所有的私有成员以及保护成员 。
声明友元函数：把函数的声明写在类中，无论私有共有保护，然后写入friend +类型+ 函数名（形参）
4、友元类：类B为类A的友元类
B类和A类是两个类，友元类B必须在A类内说明（friend class B），B类所有成员函数都有权访问A类的所有成员
5、友元的三个特点
Ⅰ、单方向：B是A的朋友，B可以访问A的数据，A不可以访问B的数据
Ⅱ、不传递：A是B的朋友，B是C的朋友，A和C没有朋友关系
Ⅲ、不继承：A是B的朋友，B是C的父亲，A和C没有关系

下面展示的是友元类的定义和使用，友元函数与其类似。

#include<iostream>
using namespace std;
class School;
class Student
{
private:
 const char* m_name;
 int m_age;
 const char* m_sex;
public:
 Student(const char* name, int age, const char* sex);
 void show(School &school);
};
class School
{
private:
 
 const char* m_schoolname;
 const char* m_address;
public:
 friend class Student;//友元类
public:
 School(const char* shoolname, const char* address);
};
Student::Student(const char* name, int age,const char* sex): m_name(name), m_age(age), m_sex(sex) {}
School::School(const char* address,const char* school):m_schoolname(school),m_address(address){}
void Student::show(School& school)
{
 cout << "姓名是" << m_name<<"\t" << "年龄是" << m_age<<"\t" << "性别：" << m_age << endl;
 cout << "校址" << school.m_address<<"\t"<< "校名" << school.m_schoolname << endl;
}
int main()
{
 Student stu("小王", 18, "男");
 School school("山东", "一中");
 stu.show(school);
 system("pause");
 return 0;
}