c++类特殊成员——常成员与静态成员

const成员

• const数据成员

  • const类型变量是不可以修改，只读模式

  • 必须采用初始化参数列表方式进行初始化

• const成员函数

  • 写法上, const写在函数名后面

  • 常成员函数是不能够修改数据成员，只读数据成员

  • 常成员函数可以与普通函数同时存在

    • 普通函数和常成员函数相同时,普通对象优先调用普通函数，并且无法强制让普通对象调用常成员函数

    • 普通对象可以调用常成员函数（当不存在相同函数名的普通成员函数时）

• const对象： const修饰的对象

  • 常对象只能调用常成员函数

 

  const数据成员

• 我们在使用常数据成员的时候，就不可以用默认的构造函数来进行赋值
•  当然，你自己写的构造函数也是不可以运行的
• 
•  常数据成员我们必须使用初始化参数列表来进行赋值

  class MM
  {
  public:
  	MM(string name, int age):name(name),age(age) {}  
  	//使用初始化参数列表就可以对常数据成员进行初始化了
  protected:
  	string name;
  	const int age;  //这就是常数据成员
  };
  int main()
  {
  	MM mm = { "lisa",20 };
  	return 0;
  }

 

 const成员函数

• 常成员函数需要记住它的写法，然后它是无法改变数据成员的，他只可以读取 
•  就算常成员函数与普通成员函数重名（这里可以理解成函数重载），普通对象也只会调用普通成员函数（这里可以理解为门当户对）。如果只有一个常成员函数，普通对象才会去调用常成员函数

  class MM
  {
  public:
  	MM(string name, int age):name(name),age(age) {}  
  	void print() const {  
  		cout << "这是常成员函数：";
  			cout << name << "\t" << age << endl;
  
  	}
  	void print(){
  		cout << "这是普通成员函数：";
  		cout << name << "\t" << age << endl;
  
  	}
  protected:
  	string name;
      int age;  
  };
  int main()
  {
  	MM mm = { "lisa",20 };
  	mm.print();
  	/*打印结果
  	  这是普通成员函数：lisa  20 
  			   */
  	return 0;
  }

  class MM
  {
  public:
  	MM(string name, int age):name(name),age(age) {}  
  	void print() const {  
  		cout << "这是常成员函数：";
  			cout << name << "\t" << age << endl;
  
  	}
  protected:
  	string name;
      int age;  
  };
  int main()
  {
  	MM mm = { "lisa",20 };
  	mm.print();
  	/*打印结果
  	 这是常成员函数：lisa    20
  			   */
  	return 0;
  }

 const对象： const修饰的对象

• 常对象只有一点需要记住，它只能调用常成员函数 

 

static成员

static成员不属于对象，而是属于类的，意味着是所有对象共有的，调用可以不需要对象，当然你也可以用对象调用

static成员依旧受权限限定。

• static数据成员

  • 必须在类外初始化，不再需要static修饰，但是需要类名限定

  • 类中初始化是错误的，不能采用初始化参数列表方式初始化

• static成员函数

  • static写在函数前面即可

  • 调用非静态成员 必须要指定对象

• static对象

  • 只用记住static对象的释放是最后释放的

 static数据成员

• 这种数据成员不可以在类中初始化，当然，也不可以用初始化参数列表
•  我们也没有办法在定义数据成员的时候进行初始化
•  所以我们只能在类外进行初始化，但是要加上类名限定

  class MM
  {
  public:
  	MM(string name):name(name) {}  
  	void print() {
  		cout << name << "\t" << age << endl;
  	}
  protected:
  	string name;
  public:
      static int age;  
  };
  //类外初始化，不再需要static修饰，但是需要类名限定
  int MM::age = 20;
  int main()
  {
  	MM mm("小红");
  	mm.print();
  	/*打印结果
  	  小红    20
  	*/
  	return 0;
  }

  class MM
  {
  public:
  	MM(string name="") :name(name) {
  		age++;  //在构造函数进行++处理，每构造一个对象，age都会加一
  	}
  protected:
  	string name;
  public:
      static int age;  
  };
  //类外初始化，不再需要static修饰，但是需要类名限定
  int MM::age = 1;
  int main()
  {
  	//静态数据成员访问，可以不需要对象
  	cout << MM::age << endl;
  
  	//什么叫做共有的(静态数据成员可以通过对象去访问)
  	MM mm("mm");
  	cout << mm.age << "\t";      //此时num等于1+1=2
  	MM array[3];			     //此时num等于2+3=5
  	MM* p = new MM("newMM");	 //此时num等于5+1=6
  	cout << MM::age << "\t";
  	cout << p->age << "\t";
  	cout << mm.age << "\t";
  	delete p;
  	p = nullptr;
  	/*从打印结果可以看出来，静态数据是不属于对象，而是属于类的
      不管从哪个对象来访问或者直接访问age都是同一个值
      打印结果 
  	  1
        2       6       6       6
  	*/
  	return 0;
  }

 static成员函数

• 静态成员函数如果是无参的就不能直接访问非静态数据成员，如果它是传参的，就可以通过传入进来的实参的访问来间接访问非静态数据成员 ，也就是在调用非静态数据成员时要指定对象

  class MM
  {
  public:
  	MM(string name="") :name(name) {}
  	static void printMM();   //类内定义，类外实现
  	static void printData(MM& mm)  //类内定义，类内实现
  	{
  		cout << mm.name << " " << age << endl;
  	}
  protected:
  	string name;
  public:
      static int age;  
  };
  int MM::age = 1;
  void MM::printMM()
  {
  	//调用非静态数据成员，必须要指定对象
  	//cout << name << endl;  当这个函数不采用对象去调用，name没有来源
  	// 所以无参的静态成员函数是不可以直接访问普通数据成员的
  	//静态调用静态，没什么要求，因为静态数据是共有的
  	cout  << age << endl;
  	cout << "静态成员函数" << endl;
  }
  int main()
  {
  	//静态成员函数
  	MM mm("小红");
  	MM::printMM(); //直接通过类调用 这样就不会有对象，所以无法访问非静态数据成员
  	mm.printMM();  //通过对象调用
  	MM::printData(mm);  //通过传参的方式去用mm调用
  	/*打印结果
  	  1
        静态成员函数
        1
        静态成员函数
        小红 1
  	*/
  	return 0;
  }

我们到这里已经讲完了类中const和static两种特殊的成员，要记住他们的使用是和普通的成员有所区别的，这里需要大家记住他们的区别。