c++中的类和对象

ly@눈_눈

已于 2023-04-09 20:05:57 修改

阅读量124

点赞数 7

分类专栏： c及c++笔记文章标签： c++ 开发语言

于 2023-02-22 17:12:07 首次发布

本文链接：https://blog.csdn.net/weixin_68278653/article/details/129149604

版权

c及c++笔记专栏收录该内容

18 篇文章 0 订阅

订阅专栏

类和对象

1.类的定义

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数，如果以C++方式实现，会发现struct中也可以定义函数，不过c++中更喜欢用class来代替。

class className
{
// 类体：由成员函数和成员变量组成
}; // 一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
访问限定符：public(公有)、protected(保护)、private(私有)

public修饰的成员在类外可以直接被访问
protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
class的默认访问权限为private，struct为public(因为struct要兼容C)

class Date
{
public:
void Init(int year)
{
    _year = year;
}
private:
    int _year;
};

如上就是一个简单的类。

2.类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 ::
作用域操作符指明成员属于哪个类域。
如： className::函数

class Date
{
public://公有，可以直接访问
void Init(int year);

private://私有，不能直接访问
    int _year;
};

// 这里需要指定Init是属于Date这个类域
void Date::Init(int year)
{
	_year = year;
}

3.类的大小

每个对象中如果都保存一份代码，相同代码(成员函数)保存多次，浪费空间，所以将类里面的成员函数存放在公共的代码段，成员变量则保存在每个对象中。
一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐。注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

// 类中既有成员变量，又有成员函数
class A1 {
public:
	void f1() {}
private:
	int _a;
};
// 类中仅有成员函数
class A2 {
public:
	void f2() {}
};
// 类中什么都没有---空类
class A3
{};
int main()
{
	cout << sizeof(A1) << endl << sizeof(A2) << endl << sizeof(A3) << endl;
}

在这里插入图片描述
结构体内存对齐规则：

第一个成员在与结构体偏移量为0的地址处。
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
注意：对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。
VS中默认的对齐数为8
结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

4.this指针

C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

class Date
{
public:
    void Init(int year)
    {
       // _year = year;
        cout << this << endl;//this指针编译器自己完成
        this->_year = year;
    }
    void Print()
    {
        cout << _year << endl;
    }
private:
    int _year;
};
int main()
{
    Date d1;
    d1.Init(2023);
    d1.Print();
    return 0;
}

this指针的特性：

this指针的类型：类型* const，即成员函数中，不能给this指针赋值。
只能在“成员函数”的内部使用
this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

5.类的默认成员函数

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

5.1构造函数

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。 构造函数的作用是初始化对象。
构造函数的特征：

函数名与类名相同。
无返回值。
对象实例化时编译器自动调用对应的构造函数。
构造函数可以重载。(函数名相同，参数类型不同)
如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
编译器对基本类型(内置类型)不初始化，对自定义类型进行初始化。注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在
类中声明时可以给默认值。

class Time
{
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};

如下则有构造函数：

class Date
{
public:
    Date(int year)//函数名与类名相同
    {
        _year = year;
    }
    void Print()
    {
        cout << _year << endl;
    }
private:
    int _year;
};
int main()
{
    Date d1(2023);
    d1.Print();
    return 0;
}

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
构造函数的初始化列表：初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
构造函数初始化列表的特征：

每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)；
类中包含引用成员变量，const成员变量，自定义类型成员(且该类没有默认构造函数时)必须放在初始化列表位置进行初始化；
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

class Date
{
public:
    Date(int year, int month)
    :_year(year)
    ,_month(month)
    { }
    void Print()
    {
        cout << _year << "年" << _month << "月" << endl;
    }
private:
    int _year;
    int _month;
};
int main()
{
    Date d1(2023, 2);
    d1.Print();
    return 0;
}

5.2析构函数

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
析构函数的特征：

析构函数名是在类名前加上字符 ~。
无参数无返回值类型。
一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
对象生命周期结束时，C++编译系统系统自动调用析构函数。
编译器生成的默认析构函数，对自定类型成员调用它的析构函数。
如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

class A
{
public:
	A()
	{
		_a = new int[10]{ 0, 1, 2,3, 4,5,6,7,8,9 };
	}
	void Print()
	{
		for (int i = 0; i < 10; ++i)
		{
			cout << _a[i] << ' ';
		}
		cout << endl;
	}
	~A()//析构函数
	{
		delete[] _a;
	}
private:
	int* _a;
};
int main()
{
	A a;
	a.Print();
	return 0;
}

5.3拷贝构造函数

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
拷贝构造函数的特征：

拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// Date(Date d)   // 错误写法
	Date(Date& d)      // 正确写法
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

若未显式定义，编译器会生成默认的拷贝构造函数。

5.4赋值运算符重载

赋值运算符重载：C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数， 也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。（.* :: sizeof ?: . ）注意以上5个运算符不能重载。
赋值运算符重载特征：

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝
赋值运算符只能重载成类的成员函数不能重载成全局函数。

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator==(Date d2)
	{
		return _year == d2._year && _month == d2._month && _day == d2._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(d1);//默认调用拷贝构造函数
	cout << (d1 == d2) << endl;
	return 0;
}

5.5const成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
在这里插入图片描述

5.6取地址及const取地址操作符重载

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可。

class Date
{
public:
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};

6.友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元分为：友元函数和友元类。

6.1友元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
如下：

class Date
{
	friend void Print(Date& d1);
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};
void Print(Date& d1)
{
	cout << d1._year << "年" << d1._month << "月" << d1._day << "日" << endl;
}
int main()
{
	Date d1;
	Print(d1);
	return 0;
}

1.友元函数可访问类的私有和保护成员，但不是类的成员函数。
2.友元函数不能用const修饰。
3.友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
4.一个函数可以是多个类的友元函数。
5.友元函数的调用与普通函数的调用原理相同。

6.2友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
1.友元关系是单向的，不具有交换性。（比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。）
2.友元关系不能传递。（如果C是B的友元， B是A的友元，则不能说明C时A的友元。）

例如：

#include<iostream>
#include<math.h>
using namespace std;

class Point {
private:
    double x;
    double y;
public:
    Point(double a,double b) {
        x = a;
        y = b;
    }
    int GetPoint() {
        cout<<" ("<<x<<","<<y<<")";
        return 0;
    }
    friend class Tool;
};

class Tool {
public:
    double GetX(Point &A) {
        cout<<A.x<<endl;
        return A.x;
    }
    double GetY(Point &A) {
        cout<<A.y<<endl;
        return A.y;
    }
    double dis(Point &A) {
        cout<<sqrt(A.x*A.x+A.y*A.y)<<endl;
        return sqrt(A.x*A.x+A.y*A.y);
    }
};

int main() {
    Point A(2.0,3.0);
    Tool T;
    T.GetX(A);
    T.GetY(A);
    T.dis(A);
    return 0;
}