C++ 基础知识七

一.静态成员变量和静态函数

关键字 static 用于说明一个类的成员，静态成员提供了一种同类对象的共享机制。

 把一个类的成员说明为 static 时，这个类无论有多少个对象被创建，这些对象共享这个 static 成员
  静态成员局部于类，它不是对象成员，在类的外部进行初始化

#include <iostream>
 
using namespace std;
 
class Test
{
public:
    Test(int a, int b)
    {
        m_a = a;
        m_b = b;
    }
public:
    int m_a;
    int m_b;
    static int m_c; // 定义一个静态的类成员，该成员是所有类对象共享的
};
 
// 静态成员必须在类的外部进行初始化
int Test::m_c = 10;
 
 
int main()
{
    Test a1(2,3);
    Test a2(3,4);
    Test a3(11,12);
 
    // 静态成员可以直接通过对象进行访问，访问方式和其他成员方式一样
    cout << a1.m_c << endl;
    
    a1.m_c = 20;
    cout << a2.m_c << endl;
   
    a2.m_c = 90;
    cout << a3.m_c << endl;
 
    // 静态成员也可以通过类型进行访问，需要用到 :: 操作符
    Test::m_c = 200;
    cout << a3.m_c << endl;
 
    return 0;
}

静态函数：

静态成员函数提供不依赖于类数据结构的共同操作，它没有this指针
在类外调用静态成员函数用 “类名 :: ”作限定词，或通过对象调用
疑难问题：静态成员函数中，不能使用普通变量，只能使用静态成员变量

#include <iostream>
using namespace std;
 
class Test
{
public:
    Test(int a, int b)
    {
        m_a = a;
        m_b = b;
    }
 
    // 静态成员函数
    // 在静态成员函数中只能使用静态变量，不能使用其他普通成员变量
    static void printC()
    {
        cout << m_c << endl;
        //cout << m_a << endl;
    }
public:
    int m_a;
    int m_b;
    static int m_c; // 定义一个静态的类成员，该成员是所有类对象共享的
};
 
// 静态成员必须在类的外部进行初始化
int Test::m_c = 10;
 
int main()
{
    Test a1(2,3);
    Test a2(3,4);
    Test a3(11,12);
 
    // 静态成员函数的使用可以使用 类名::函数名 或者 对象直接调用
    Test::printC();
    a1.printC();
 
    return 0;
}

二.对象的动态创建和释放

1）在软件开发过程中，常常需要动态地分配和撤销内存空间，例如对动态链表中结点的插入与删除。在C语言中是利用库函数malloc和free来分配和撤销内存空间的。C++提供了较简便而功能较强的运算符new和delete来取代malloc和free函数。
注意： new和delete是运算符，不是函数，因此执行效率高。
 
2）虽然为了与C语言兼容，C++仍保留malloc和free函数，但建议用户不用malloc和free函数，而用new和delete运算符。new运算符的例子：
new int;            //开辟一个存放整数的存储空间，返回一个指向该存储空间的地址(即指针)
new int(100);  //开辟一个存放整数的空间，并指定该整数的初值为100，返回一个指向该存储空间的地址
new char[10];  //开辟一个存放字符数组(包括10个元素)的空间，返回首元素的地址
new int[5][4];  //开辟一个存放二维整型数组(大小为5*4)的空间，返回首元素的地址
float *p=new float (3.14159);  //开辟一个存放单精度数的空间，并指定该实数的初值为//3.14159，将返回的该空间的地址赋给指针变量p
3)new和delete运算符使用的格式：

用new分配数组空间时不能指定初值。如果由于内存不足等原因而无法正常分配空间，则new会返回一个空指针NULL，用户可以根据该指针的值判断分配空间是否成功。

#include <stdio.h>


int main11_1()
{	

//创建普通型变量

	//new + 数据类型
	int *p1 = new int;

	*p1 = 20;
	printf ("*p1 = %d\n", *p1);

	//释放 new 空间
	delete p1;

	//new  申请空间时进行初始化
	int *p2 = new int(100);
	printf ("*p2 = %d\n", *p2);

	delete(p2);

//申请数组
	//new + 数据类型[szie]
	int *p3 = new int[10];
	//p3[10] = 0;
	
	//释放数组 delete [] + 指针变量
	delete [] p3; //[] 漏掉会造成内存泄漏

	return 0;
}

class Text11
{
public:
	Text11(int a)
	{
		m_a = a;
		printf("m_a = %d\n",m_a);
	}

	~Text11()
	{
		printf("11_1析构函数\n");
	}
private:
	int m_a;
};

int main()
{
	//用到对象时才建立对象，
	//在不需要用该对象时就撤销它，
	//释放它所占的内存空间以供别的数据使用。
	//这样可提高内存空间的利用率。

	// new 在创建对象的时候会自动构造函数进行对象的构建
	Text11 *p1 = new Text11(10);

	//delete在释放对象时会自动调用析构函数
	delete p1;

	return 0;
}

三 .THIS指针

C++中类的普通成员函数都隐式包含一个指向当前对象的this指针

#include <stdio.h>

class text
{
public:
	//C++中类的普通成员函数都隐式包含一个指向当前对象的this指针
	text(int a) //text(text *this,int a)
	{
		this->m_a = a;
	}
	void print()
	{
		printf("m_a = %d\n",m_a);
	}
private:
	int m_a;
};

int main()
{
	text t1(10);
	t1.print();

	return 0;
}

const修饰成员函数

#include <iostream>
using namespace std;
class Test
{
public:
	Test(int a, int b) //---> Test(Test *this, int a, int b)
	{
		this->a = a;
		this-> b = b;
	}
	void printT()
	{
		cout<<"a: " <<a <<endl;
		cout<< "b: " << this->b <<endl;
	}
	//const 写的什么位置 没有关系
	//const修饰的是谁？
	//const修饰的是形参a 不是
	//const修饰的是属性this->a  this->b
	//const修饰的是this指针所指向的内存空间， 修饰的是this指针

	void  OpVar( int a, int b) const   //==>void  OpVar(const Test *this, int a, int b)
		//==>void  OpVar( const Test *const this, int a, int b)
	{
		a = 100;
		//this->a = 100; //无法改变被const修饰的this->a,this->b
		//this->b = 200;
		//this = 0x11;  无法改变 this 指向

		//cout<<"a: " <<a <<endl;
		cout<< "b: " << this->b <<endl;
	}
protected:
private:
	int a;
	int b;
};

void main()
{
	Test t1(1, 2);
	t1.printT();// ===> printT(&t1)
	cout<<"hello..."<<endl;
	return ;
}