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

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

目录

 一、类

 二、struct 和class 的区别 

三、面向对象的特点(重点)

 四、类的大小

五、this指针

六、带默认值的函数

 七、内联函数:(inline)(重点)

 八、常成员函数

 一、类

(1)定义:将不同类型的数据以及这些数据相关的 *** 作封装在一起。
(2)类=属性+函数         ( *** 作属性)
  (3)访问权限——public(共有的)、protected(保护的)、private(私有的)
ps:在学习继承之前,protected不用,只用public和private

//定义一个类
class Clock
{
//公有的
public:
	void Set() 
	{
		m_hour = 20;
		m_minute = 10;
		m_second = 20;
	}//设置时间

	void Show()
	{
		cout << m_hour << ":" << m_minute << ":" << m_second<
 二、struct 和class 的区别 

(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;
}
五、this指针

(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();
}
 七、内联函数:(inline)(重点)

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;
}

如有错误,敬请指正。

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

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/langs/3002959.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-09-27
下一篇 2022-09-27

发表评论

登录后才能评论

评论列表(0条)