C++——类的基础知识（类定义、结构体、面向对象特点、类的大小、带默认值的函数、内联函数inline、常成员函数）

（1）结构体struct的默认权限是——public；
（2）类class的默认权限是——private。

测试代码： 

//结构体
struct AA
{
	void print()
	{
		cout << "AA:print" << endl;
	}
};

//类
class BB
{
	void print(){}
};

void main()
{
	AA a;
	BB b;
	a.print();
	b.print();//私有的，无法访问
}

（1）封装：属性（public）+ *** 作（private）（把属性和 *** 作放在一个集合里）；
（2）继承：是一个层次关系（从上层往下层），从下层往上层（派生）；
（3）多态：多种状态（4种）
                 ①重载多态——函数重载（函数名相同，函数参数列表不同，与返回值无关）
                                   ——运算符重载；
                 ②强制多态——强制类型转换：static_cast,dynamic_cast,cosnt_cast...
                 ③包含多态——虚函数的多态 virtual；
                 ④参数多态——模板（模型）。
（4）抽象——有时候不被认为是一个特点，是一个过程 。

ps：（严格来说只有前三个特点） 

1.一般情况下，类的大小是属性之和，普通函数不占类空间大小；
2.静态属性static不占类内存空间大小；
3.虚函数virtual在类内存分配一个指针的大小（4个字节），无论增加多少个virtual函数，都只增加一个指针大小。
 ps：（虚表中只放一个指针）

 测试代码：

class AA
{
public:
	void test()
	{
	}
	virtual void fn() {}
	virtual void fn1() {}
	virtual void fn2(){}

private:
	int m_i;
	char m_sex;
	int m_age;
	static int m_num;//静态属性
};

void main()
{
	cout << sizeof(AA) << endl;
}

（1）this——在非static成员函数中，有一个隐含的指针this，this指向当前类对象，即是接受当前类对象的地址；
（2）this是指针，只能指向->

   void Set()
	{
		m_hour = 10;
		m_minute = 20;
		m_second = 30;
	}
	void Set(int h)//c1.Set(12)
	{
		//this=&当前对象 （的地址）
		this->m_hour = h;
		this->m_minute = 10;
		this->m_second = 30;
	}//设置时间  h:10:30
	void Set(int h, int m)
	{
		m_hour = h;
		m_minute = m;
		m_second = 30;
	}
	void Set(int h, int m,int s)
	{
		m_hour = h;
		m_minute = m;
		m_second = s;
	}


	void Show();
	{
		cout << this->m_hour << ":" << m_minute << ":" << m_second << endl;
	} 
	

注意：
1.一般情况下，尽量把参数都带上默认值；如果有不带默认值的，一定在前面，即是有一个参数带默认值了，它后面的参数必须带默认值；

2.在声明的时候带默认值，如果放在类外定义次函数，则默认值不需要再定义 。

class Clock
{
public:
	//带默认值（缺省值）的函数
	void Set(int h = 12,int m = 30,int s=30)
	{
		m_hour = h;
		m_minute = m;
		m_second = s;
	}

private:
	int m_hour;//m_（下划线）表示成员的意思
	int m_minute;
	int m_second;
};

void Clock::Show()//把当前函数放在类外面定义，结果一样
{
	cout << this->m_hour << ":" << m_minute << ":" << m_second << endl;
}
void Set(int h, int m, int s, int f)
{

}

void main()
{
	Clock c,c1, c2, c3;
	c.Show();
	c1.Show();
	c2.Show();
	c3.Show();
}

1.函数调用——时间消耗，空间消耗
2.内联函数——代码比较短小，功能比较简单的一些函数，放在类里面直接定义，
          这些函数可以作为内联，在函数调用时直接将函数体嵌入到当前调用处，直接执行，不会有函数调用的转移
例：简单地赋值，输出，返回函数。
3.分类：隐式内联、显式内联inline
4.用空间的消耗换取了时间的消耗
5.内联函数和宏定义的区别：
（1）内联函数是——函数，宏定义是——预处理命令
（2）内联是在运行时执行，宏是编译之前执行
（3）内联不会出现歧义，宏会出现歧义

#define N 3k//本身这个宏定义没有错，

#define S(a,b)(a+b)//写的时候把括号加到不能加为止(用的时候原模原样去替换，不要加括号）

#define S(a,b)((a)*(b))
void main()
{
	cout << S(3, 4) / S(3, 4) << endl;//3+4/3+4=8；S（a,b) a+b 加上括号后结果为1
	cout << S(3 + 3, 4 + 4) << endl;//(用的时候原模原样去替换，不要加括号）
}

内联函数测试代码: 

class A
{
public:
	inline void fn(int i = 0, int j = 0, int k = 0);
	/* {
		m_i= i;
		m_j = j;
		m_k = k;
	}
	*/
	void Print()
	{
		cout << m_i<<" "<< m_j<<" " << m_k<< endl;//隐式内联
	}
	inline void Sort()//这个不会按照inline来编译
	{
		//.....
	}
private:
	int m_i;
	int m_j;
	int m_k;
};

void A::fn(int i = 0, int j = 0, int k = 0)
{
	m_i = i;
	m_j = j;
	m_k = k;
}

int main()
{
	A a, b, c, d;
	a.fn();
	b.fn(1);
	c.fn(1, 2);
	d.fn(1, 2, 3);
	a.Print();
	b.Print();
	c.Print();
	d.Print();
	a.Sort();

}

class A
{
public:
	void Set(int i = 0,int j = 0)
	{
		m_i = i;
		m_j = j;
	}

	int GetI()const//在函数后面加const，是常成员函数——不能修改本类数据成员的值，不能修改m_i和m_j
	{
		cout << "geti cosnt" << endl;
		return m_i;
	}

	int GetI()//非const对象调用
	{
		cout << "get i" << endl;
		return m_i;
	}

	/*
	* 情况一：
	int GetJ()
	{
	    return m_j;
	}
	情况二：
	int& GetJ()//返回m_j的引用
	{
		return m_j;
	}
	情况三：
	*/
	const int& GetJ()//返回m_j的引用
	{
		return m_j;
	}
	void Print()
	{
		cout << m_i << m_j << endl;
	}

private:
	int m_i;
	int m_j;
};
int main()
{ 
	A b;
	//const A b;
	b.GetI();//常成员函数GetI
	A a;
	a.Set(10, 20);
	//cout << a.m_i << endl;
	cout << a.GetI() << endl;
	//a.m_j=40;//error
	//a.GetJ() = 40;//值返回不能放在左边
	//a.GetJ() = 40;
	a.Print();
	cout << a.GetJ() << endl;
}

如有错误，敬请指正。

您的收藏与点赞都是对我最大的鼓励和支持！