C++中的静态成员与this指针

一、静态成员

1、static 关键字

  • 静态属性只能在全局范围内进行初始化赋值
  • 静态方法可以直接通过类名进行访问,也可以通过对象名进行访问
class Teacher {
private:
	char* name;
public:
	//计数器
	static int total;
public:
	Teacher(char* name) {
		this->name = name;
		cout << "Teacher有参构造函数" << endl;
	}
	~Teacher() {
		cout << "Teacher析构函数" << endl;
	}
	void setName(char* name) {
		this->name = name;
	}
	char* getName() {
		return this->name;
	}
	//计数的静态函数
	static void count(){
	    total++;
	    cout << "total:" << total << endl;
	}
};

//静态属性初始化赋值
int Teacher::total = 10;

void main() {
    Teacher::total++;
	cout << Teacher::total << endl;
	//直接通过类名访问
	Teacher::count();
	cout << Teacher::total << endl;
	//通过对象名访问
	Teacher t1((char*)"JACK");
	t1.count();
	cout << Teacher::total << endl;
	getchar();
}

二、类的大小

C/C++ 内存分区:栈、堆、全局(静态、全局)、常量区(字符串)、程序代码区
普通属性与结构体具有相同的内存布局

class A {
public:
	int i;
	int j;
	int k;
};

class B {
public:
	int i;
	int j;
	int k;
	void myprint() {
		cout << "打印" << endl;
	}

};

void main() {
	cout << sizeof(A) << endl;
	cout << sizeof(B) << endl;
	getchar();
}

三、this 指针

1、this指针

this 是当前对象的指针
因为函数是共享的,所有使用this指针用来标识当前对象

class Teacher {
private:
	char* name;
	int age;
public:
	Teacher(char* name,int age) {
		this->name = name;
		this->age = age;
		cout << "Teacher有参构造函数" << endl;
	}
	~Teacher() {
		cout << "Teacher析构函数" << endl;
	}
	void setName(char* name) {
		this->name = name;
	}
	char* getName() {
		return this->name;
	}
	void setAge(int age) {
		this->age = age;
	}
	int getAge() {
		return this->age;
	}
	void myprint() {
		cout << this->getName() << "," << this->getAge() << endl;
	}
};


void main() {
	Teacher t1((char*)"Jack", 20);
	Teacher t2((char*)"Rose", 18);
	t1.myprint();
	t2.myprint();
	getchar();
}

2、常函数(const修饰函数)

常函数,修饰的是this;既不能改变指针的值,也不能改变指针指向的内容
常量对象只能调用常量函数,不能调用非常量函数
常函数当前对象不能被修改,防止数据成员被非法访问

class Teacher {
private:
	char* name;
	int age;
public:
	Teacher(char* name,int age) {
		this->name = name;
		this->age = age;
		cout << "Teacher有参构造函数" << endl;
	}
	~Teacher() {
		cout << "Teacher析构函数" << endl;
	}
	void setName(char* name) {
		this->name = name;
	}
	char* getName() {
		return this->name;
	}
	void setAge(int age) {
		this->age = age;
	}
	int getAge() {
		return this->age;
	}
	void myprint() const {
	    printf("%#x\n",this);
	    //不能改变属性的值
	    //this->name = "Jason";
	    //不能改变this指针的值
	    //this = (Teacher*)0x000090;
		cout << this->getName() << "," << this->getAge() << endl;
	}
};

四、友元函数与友元类

1、友元函数

在友元函数中可以访问私有的属性

class A {
private:
	int i;
public:
	A(int i) {
		this->i = i;
	}
	void myprint() {
		cout << i << endl;
	}
	//友元函数
	friend void modify_i(A*p, int a);
};

//友元函数的实现,在友元函数中可以访问私有的属性
void modify_i(A*p, int a) {
	p->i = a;
}

void main() {
	A* a = new A(10);
	a->myprint();
	modify_i(a, 20);
	a->myprint();
	getchar();
}

2、友元类

友元类可以访问引用友元类的类的任何成员

class A {
	//友元类
	friend class B;
private:
	int i;
public:
	A(int i) {
		this->i = i;
	}
	void myprint() {
		cout << i << endl;
	}
	//友元函数
	friend void modify_i(A*p, int a);
};

//友元函数的实现,在友元函数中可以访问私有的属性
void modify_i(A*p, int a) {
	p->i = a;
}

class B {
private:
	A a;
public:
	B(int a_i):a(a_i) {
		this->a = a;
	}
	//B这个友元类可以访问A类的任何成员
	void accessAny() {
		a.i = 30;
	}
	A getA() {
		return a;
	}
};

void main() {
	B* b = new B(10);
	A a = b->getA();
	a.myprint();
	b->accessAny();
	a = b->getA();
	a.myprint();
	getchar();
}

五、运算符重载

运算符的重载,本质上还是函数的调用

1、单独进行运算符重载

class Point {
public:
	int x;
	int y;
public:
	Point(int x = 0,int y = 0) {
		this->x = x;
		this->y = y;
	}

	void myprint() {
		cout << x << "," << y << endl;
	}
};
//重载+号
Point operator+(Point &p1, Point &p2) {
	Point tmp(p1.x + p2.x, p1.y + p2.y);
	return tmp;
}

//重载-号
Point operator-(Point &p1, Point &p2) {
	Point tmp(p1.x - p2.x, p1.y - p2.y);
	return tmp;
}

void main() {
	Point p1(10,20);
	Point p2(20,10);
	Point p3 = p1 + p2;
	p3.myprint();
	getchar();
}

2、类成员函数运算符重载

class Point {
public:
	int x;
	int y;
public:
	Point(int x = 0, int y = 0) {
		this->x = x;
		this->y = y;
	}

	void myprint() {
		cout << x << "," << y << endl;
	}
	//成员函数运算符重载+号
	Point operator+(Point &p2) {
		Point tmp(this->x + p2.x, this->y + p2.y);
		return tmp;
	}

	//成员函数运算符重载-号
	Point operator-(Point &p2) {
		Point tmp(this->x - p2.x, this->y - p2.y);
		return tmp;
	}
};


void main() {
	Point p1(10, 20);
	Point p2(20, 10);
	//p1.operator+(p1);
	Point p3 = p1 + p2;
	p3.myprint();
	getchar();
}

3、友元函数运算符重载

当属性私有时,通过友元函数完成运算符重载

class Point {
	friend Point operator+(Point &p1, Point &p2);
	friend Point operator-(Point &p1, Point &p2);
private:
	int x;
	int y;
public:
	Point(int x = 0, int y = 0) {
		this->x = x;
		this->y = y;
	}

	void myprint() {
		cout << x << "," << y << endl;
	}
	
};

//友元函数运算符重载+号
Point operator+(Point &p1, Point &p2) {
	Point tmp(p1.x + p2.x, p1.y + p2.y);
	return tmp;
}

//友元函数运算符重载-号
Point operator-(Point &p1, Point &p2) {
	Point tmp(p1.x - p2.x, p1.y - p2.y);
	return tmp;
}

void main() {
	Point p1(10, 20);
	Point p2(20, 10);
	Point p3 = p1 + p2;
	p3.myprint();
	getchar();
}