C++关于类的大小、与class的区别等问题详解（附代码）

A steria.

已于 2022-09-29 19:24:36 修改

阅读量562

点赞数

分类专栏：新手入门 struct类 C++笔记文章标签： c++

于 2022-09-25 13:44:59 首次发布

本文链接：https://blog.csdn.net/m0_59052131/article/details/127036831

版权

新手入门同时被 3 个专栏收录

31 篇文章 0 订阅

订阅专栏

C++笔记

22 篇文章 2 订阅

订阅专栏

struct类

1 篇文章 0 订阅

订阅专栏

1.类的定义

抽象出来的，将现实生活中实实在在的一些实体的共性抽象出来，形成一个类型将不同类型的数据以及与这些数据相关的操作封装在一起，构成一个新的数据类型,实现不占用内存单元将不同类型的数据以及这些数据相关的操作封装在一起
属性+函数

class Clock//类名，一般大写
{
public:
	//带默认值的函数（带缺省值的函数），可替代重载函数
	void Set(int h = 12, int m = 30, int s = 30)
	{
		m_hour = h;
		m_minute = 20;
		m_second = 30;
	}
	void Show()//显示时间
	{
		cout << m_hour << ":" << m_minute << ":" << m_second << endl;
	}
protected:
	int m_test;
private:
	int m_hour;//m_表示成员的意思
	int m_minute;
	int m_second;
};

2.类的大小

1.一般情况下是属性之和，普通函数（在代码区）不占类空间大小
2.static属性不占类空间大小
3.virtual虚函数在类中分配一个指针大小，不管有多少个虚函数都只一个指针大小//原因：虚指针指向虚表入口，不管有多少都指向这一张表的入口

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

3.访问权限

访问权限--public，protected,private
在继承之前protected可以不用

class Clock//类名，一般大写
{
public:
	void Set()//设置时间
	{
		m_hour = 02;
		m_minute = 11;
		m_second = 09;
	}
	void Show()//显示时间
	{
		cout << m_hour << ":" << m_minute << ":" << m_second << endl;
	}
protected:
	int m_test;
private:
	int m_hour;//m_表示成员的意思
	int m_minute;
	int m_second;
};
void main()
{
	Clock c;//Clock类定义了一个名为c的对象
	//c.m_test = 10;//在外界不能访问保护和私有的
	//c.m_hour = 20;//在外界不能访问保护和私有的
	c.Set();
	c.Show();
}

4.struct 和class的区别

struct 的默认权限是public
class 的默认权限是private

5.面向对象的特点：

封装继承多态；抽象
封装--属性（private）+操作（public）
继承--上层和下层关系
多态--多种状态或形态
4种多态
1.重载多态：函数重载//函数名相同参数列表不同，通过返回值不能确定重载
运算符重载
2.强制多态：强制类型转换 static_cast，dynamic_cast，const_cast，reinterpret_cast
3.包含多态：virtual--虚函数
4.参数多态：模板

struct AA
{
	void print() { cout << "AA：print" << endl; }
};

class BB
{
	void print() {}
};

void main()
{
	AA a;
	BB b;
	a.print();
	//b.print;
}

6.类中隐藏的this指针

this--在非（static）静态成员函数中，有一个隐含的指针this，this指向当前类对象，即是接收当前类对象地址 this=&当前对象

class Clock
{
public:
	void Set(int h)//c1.Set(12) c1.Set(&c1,12)
	{//this=&当前对象
		this->m_hour = h;
		this->m_minute = 20;
		this->m_second = 30;
	}
	void Show()//显示时间
	{
		cout << this->m_hour << ":" << this->m_minute << ":" << this->m_second << endl;
	}
protected:
	int m_test;
private:
	int m_hour;
	int m_minute;
	int m_second;
};

void main()
{
	Clock c1, c2;
	c1.Set(12);
	c1.Show();
	c2.Set(9);
	c2.Show();

}

7.类中的函数重载

        1.函数名相同（同一个作用域）
        2.函数的参数列表不同（参数的类型，个数，顺序）
        3.和函数返回值无关
        4.和常成员函数无关

class Clock
{
public:
	void Set()
	{
		m_hour = 1;
		m_minute = 20;
		m_second = 30;
	}
	void Set(int h)
	{
		this->m_hour = h;
		this->m_minute = 20;
		this->m_second = 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 << ":" << this->m_minute << ":" << this->m_second << endl;
	}
protected:
	int m_test;
private:
	int m_hour;
	int m_minute;
	int m_second;
};
void Clock::Show()
{
	cout << this->m_hour << ":" << this->m_minute << ":" << this->m_second << endl;
}

//void ::Show()//不能重载，函数名不同
void Set(int h, int m, int s, int f)
{
}

void main()
{
	Clock c, c1, c2, c3;
	c.Set();
	c.Show();
	c1.Set(12);
	c1.Show();
	c2.Set(9,11);
	c2.Show();
    c3.Set(4,5,6);
	c3.Show();    

}

8.带默认值的函数注意

        1.一般情况下，尽量参数都带默认值
          如果有不带的，一定在前面，即是有一个参数带默认值了，它后面的必须带默认值
        2.在声明的时候带默认值，如果放在类外定义此函数，则默认值不需要再定义

class A
{
public:
	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; }//隐式内联
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;
		}*/
};

void 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();
}