一起学习 05特殊成员 C++

特殊成员

const 成员

• const数据成员
  • const类型变量是不可以修改，只读模式
  • 必须采用初始化参数列表方式进行初始化

#include<iostream>
#include<string>
using namespace std;
class MM {
public:
	MM(string name,int num) :num(num) {
		MM::name = name;   //可以用，也可以不用初始化列表
		//MM::num = 1001; wrong必须要用初始化参数列表方式初始化
	}
protected:
	const int num;
	string name;
};
int main() {
	MM mm("YY", 22);
	while (1);
	return 0;
}

• const成员函数
  • 写法上, const写在函数后面
  • 常成员函数是不能够修改数据成员，只读数据成员
  • 常成员函数可以与普通函数同时存在
    • 普通函数和常成员函数相同时,普通对象优先调用普通函数
    • 普通对象可以调用常成员函数
• const对象： const修饰的对象
  • 常对象只能调用常成员函数

#include<iostream>
#include<string>
using namespace std;
class MM {
public:
	MM(string name,int num) :num(num) {
		MM::name = name;   //可以用，也可以不用初始化列表
		//MM::num = 1001; wrong必须要用初始化参数列表方式初始化
	}
	void print()
	{
		//num = 1122;
		cout << name << " " << num << endl;
	}
	void print() const
	{
		//name = "HH";常成员函数 不可修改数据
		//num = 2233;
		cout << "Im const funcction,Icant change data\n" << endl;
	}
	void printdata()
	{
		cout << name << "Im ordinary funnction" << num << endl;
	}
protected:
	const int num;
	string name;
};
int main() {
	MM mm("YY", 22);
	mm.print();            //普通对象调用普通函数
	const MM m("TT", 21);
	m.print();        //常对象调用常成员函数
	//m.printdata()   //错误!,常对象只能调用普通函数
	while (1);
	return 0;
}

static成员

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

• static成员依旧受权限限定。

• static数据成员

  • $$$必须在类外初始化，不再需要static修饰，但是需要类名限定
  • 类中初始化是错误的，不能采用初始化参数列表方式初始化

#include"iostream"
#include<string>
using namespace std;
class Boy {
public:
	//+必须在类外初始化，不再需要static修饰，但是需要类名限定
	//+ 类中初始化是错误的，不能采用初始化参数列表方式初始化
	Boy(string name = "") :name(name) {
		//Boy::name = name; 可以不写
		num++;
	}
	void print() {
		cout << name << " " << num << endl;
	}
protected:
	static int num;
	string name;
};
//类外初始化，不再需要static修饰，但是需要类名限定
int Boy::num = 22;
int main() {
	Boy boy("boy");
	boy.print();
	while (1);
	return 0;
}

• static成员函数
  • static写在函数前面即可
  • 调用非静态成员 必须要指定对象
• static对象
  • 释放是最后释放的

 #include"iostream"
#include<string>
using namespace std;
class Boy {
public:
	//+必须在类外初始化，不再需要static修饰，但是需要类名限定
	//+ 类中初始化是错误的，不能采用初始化参数列表方式初始化
	Boy(string name = "") :name(name) {
		//Boy::name = name; 可以不写
		num++;
	}
	void print() {
		cout << name << " " << num << endl;
	}
	static void printboy();
	static void printbo(Boy& Bo)
	{
		cout << "内部static函数" << Bo.name << " " << Bo.num << endl;
	}
public:
	static int num;
	string name;
};
//类外初始化，不再需要static修饰，但是需要类名限定
int Boy::num = 22;
//类外初始化，不再需要static修饰
void Boy::printboy()
{
	cout << "Im static function" << endl;
	// 不这样写，写下面方法   不行 Boy：：printboy()
	//cout << Boy.name << " " <<Boy. num << endl;  错误！！！
	//cout << Boy::name << name << num << endl; !!!!!!!name Cant print!
	cout << num << endl;
}
int main() {
	//访问静态数据成员 可以不需要 对象
	cout << Boy::num << endl;//22
	Boy::printboy();// 此出 意外发现调用static 函数可以不用对象？？？22
	// 证明 static 数据成员是共有
	Boy bo("bo");//22

	//静态数据成员可以通过对象去访问
	cout << bo.num << endl;// num 为23
	Boy Bo[4];  // num 23+4
	cout << Bo->num << endl;
	Boy* b = new Boy("newboy");//27+1

	cout << Boy::num << endl;
	cout << b->num << endl;
	cout <<bo.num << endl;
     delete b;
	 b = nullptr;

	//静态成员函数
	 Boy::printboy();
	 bo.printboy();
     Boy::printbo(bo);
	while (1);
	return 0;
}

友元

<202111281:12>明天补
描述关系：
给对象发放特许牌，让他有特权访问
赋予对象具有打破类的权限定(无视权限)

• 友元函数
  • 普通友元函数
  • 以另一个类的成员函数充当友元函数，顺序如下：
    • B 类{function}
    • A类
    • A类的 友元函数function

#include"iostream"
#include<string>
using namespace std;
class A {
public:
    A(string name, int num) :name(name), num(num) {}

         void print() {
		 cout << "Im function of A" << endl;
         cout << name << "" << num << endl;
         }
protected:
    string name;
private:
    int num;
    friend  void printData2(A& mm);
};
void printData2(A& mm)// friend function
{
    cout << mm.name << "\t" << mm.num << endl;
}
int main() {
    A aa("AA", 23);
    aa.print();
    printData2(aa);// friend function
    while (1);
    return 0;
}

友元类

• 1.在A 中 标识 B为朋友
  并在A内就写 构造和数据成员
• 2 .B中创建 A 的对象或者 传进来 访问打印
  互为友元类：可以互相访问

#include <iostream>
class AA
{
	friend class BB;                      // BB 为AA朋友，他可以访问AA的成员
public:
	AA(string name, int age) :name(name), age(age) {}
protected:
	string name;
	int age;
};
class BB
{
public:
	void print()
	{
		AA aa("aa", 22);
		cout << aa.name << "\t" << aa.age << endl;
	}
	void printAA(AA& aa)
	{
		cout << aa.name << "\t" << aa.age << endl;
	}
	AA& returnAA(AA& aa)
	{
		return aa;
	}
protected:
};
//互为友元类的写法
class A
{
	friend class B;
public:
	void printData();
protected:
	string data ="A";
};

class B
{
public:
	friend class A;
	void printData()
	{
		A a;
		cout << a.data << endl;
	}
protected:
	string data="B";
};
void A::printData()
{
	B b;
	cout << b.data << endl;
}
int main()
{
	AA aa("aa", 23);
	
	BB bb;
	bb.print();//B里创建打印aa       //   BB 为AA朋友，他可以访问AA的成员
	bb.printAA(aa);// 在B 里访问 打印A    BB 为AA朋友，他可以访问AA的成员
	//cout << bb.returnAA(aa).name << endl;  错误，出了友元类，没有权限

	//互为友元
	B b;
	b.printData();
	A a;
	a.printData();
	return 0;
}

this指针与explicit

• explicit修饰的构造函数使用，不让隐式转换构造

• this指针

  • 避免形参名和数据成员同名，通指对象的地址
  • 充当函数返回值，返回对象自身，用*this表示对象本身
  • 静态成员函数中是不能使用this指针！！！
    

#include<iostream>
#include<string>
using namespace std;
class AA {
public:
	AA(string name, int age) {
		this->name = name;//  出别 同名形参 和数据成员
		this->age = age;
	}
	void print() {
		cout << (*this).name << '\t' << (*this).age << endl; // this 取 * 运算为对象自己
	}
	    friend void printdata(AA&a);
const	friend void printdata2(AA& a);
protected:
	int age;
	string name;
};

void printdata(AA& a) {
	cout << a.name << "   friend"<<'\t' << endl;
}
const void printdata2(AA& a) {
	cout << /*this.name */a.name<< a.age << '\t' << endl;
}
int main() 
{
	AA a("A", 22);
	a.print();
	printdata(a);
	cout << "In const function cant use this" << endl;
	printdata2(a);

	while (1);
	return 0;
}

总结

• 普通函数不存在初始化参数列表
• explicit MM(int age) :age(age) {} void print() { cout << age << endl; }//
  //explicit 不让隐式转换构造
  //MM mm = 12;
  //MM temp = 1.33;
  ****** 物理考的很烂，复变函数 也差，英语还行
  期末好好努力，还有一个月。
  希望 Mycoding 和专业学习兼并行加油！