【1++的C++初阶】之类与对象

最新推荐文章于 2024-11-14 19:11:37 发布
最新推荐文章于 2024-11-14 19:11:37 发布
阅读量647 收藏 2
点赞数 5
分类专栏： 1++的C++初阶 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63135219/article/details/130466479
版权
本文详细介绍了C++中的面向对象编程基础，包括类的定义、访问限定符、封装的概念和作用，以及this指针的原理。文章还深入讨论了构造函数、析构函数、拷贝构造函数、赋值运算符重载以及取地址操作符重载的细节，强调了在资源管理中的重要性。此外，还提到了默认成员函数、静态成员、友元和内部类的相关知识。
摘要由CSDN通过智能技术生成

👍作者主页：进击的1++
🤩 专栏链接：【1++的C++初阶】

文章目录

一，面向对象与面向过程

C语言是面向过程的语言，关注的是过程，解决问题的步骤；而C++是面向对象的语言，关注的是对象之间的交互。例如，泡泡面，在C语言中，我们关注的泡泡面的步骤----打开泡面-放入调料包-倒入热水-等待；在C++中关注的是：泡面，热水两个对象之间的交互。我们不需要关注泡泡面的具体步骤。

二，类

2.1 类的定义

class Person
{
	int age;
	char name;
	int infor;
	int* _a;

};

以上述代码为例：class为定义类的关键字，(也可以是struct, 在C++中，struct上升为类）Person为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省 略。类中的内容称为类的成员，类中定义的变量称为成员变量，类中的函数称为成员函数或方法。 成员函数的定义有两种方式:一种是定义在类中的，这时，编译器可能将其当作内联函数处理；另一种是定义与声明分离，声明在类中，定义在另一个.cpp文件中。

2.2 类的访问限定符

访问限定符有：public,private,protected。其中被public修饰的成员，能够在类外被直接访问，而被private,protected修饰的成员在类外不能直接被访问。要注意的是，struct定义的类的默认访问权限是public。而class默认的访问权限是private。

示例代码：

class Person
{
public:
	void add()
	{
		int* a = (int*)malloc(sizeof(int) * 20);
		assert(a);
		_a = a;
		cout <<"add" << endl;
	}
private:
	int age;
	char name;
	int infor;
	int* _a;

};

2.3 封装

2.3.1 什么是封装

将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

2.3.2 封装的作用

封装的实质就是一种管理，方便对类的使用。

2.4 类与对象

类的实例化实际就是用类创建对象的过程。 类是对对象进行描述的，相当于在建房子时的一张图纸，而实例化出的对象则是建好的房子，因此。只有对象才占用实际的物理空间。 每个对象中成员变量是不同的，但调用的都是同一份函数，因此，成员函数会放在一个公共区域中，避免浪费空间，因此在计算对象的大小时，只需计算成员变量的大小，但要记得内存对齐。空类实例化的对象比较特殊，有一个字节大小。

三，this指针

3.1 什么是this指针

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

3.2 this指针的特性

  1. this指针实际是一个指向对象的指针，因此它的类型为对象的类型+*const。即this指针是不能赋值的。
  2. this指针只能在成员函数内部使用。
  3. this指针是形参，所以它储存在函数栈帧里。
  4. 当在成员函数中不去访问成员变量时，this指针是可以为空的。

在这里插入图片描述

下图，我们可以看到程序崩溃

四，类的六个默认成员函数

4.1 什么叫默认成员函数

默认成员函数就是用户没有显式定义，编译器会生成的成员函数。有以下六个默认成员函数：1，构造函数：完成初始化工作；2，析构函数：完成销毁清理工作；3，拷贝构造：使用同类对象初始化创建对象；4，赋值重载：主要是把一个对象赋值给另一个对象；5，6，取地址及const取地址操作符重载。 因此，在空类中，并不是什么都没有，编译器会自动生成这些默认成员函数。

4.2 构造函数

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

以下代码为例：

class Date
{
public:
	Date()
	{
		_year = 2023;
		_month = 5;
		_day = 3;
	}

	Date(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(2022, 4, 21);
	return 0;
}

运行结果：
在这里插入图片描述

在上述代码中，我们定义了两个构造函数，一个是无参的，一个则是有参的，要注意的是对于无参的写法，不可以写为Date d1()，这样编译器会将其当做声明。并且，一但用户显式定义构造函数，编译器便不再自动生成，因此，不论你写了一个带参数还是不带参数的构造函数，就会认定为你显式定义了，编译器不会再生成。

如下图：
在这里插入图片描述

当我们不显式定义构造函数，而是让编译器去自动生成。在下图，我们就会发现，d1对象依旧是随机值。

在这里插入图片描述

这是为什么呢？在C++中，把类型分为了内置类型和自定义类型。内置类型就是语言本身提供的数据类型，就像int char float等，自定义类型，就是用class,struct,union自己定义的类型。在C++11之前，编译器生成的默认构造函数只对自定义类型成员会去自动调用它的构造函数，在C++11之后，打了一个补丁，内置类型成员，可以在类中声明时给默认值。

示例代码如下：

class Time
{
public:
	Time()
	{
		tt = 2104;
	}
private:
	int tt;
};

class Date
{
public:
	
	Date()
	{
		_year = 2023;
		_month = 5;
		_day = 3;
	}

	/*Date(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}*/
private:
	int _year;
	int _month;
	int _day;
	Time t;
};
int main()
{
	Date d1;
	//Date d2(2022, 4, 21);
 	return 0;
}

运行结果：
在这里插入图片描述

无参的构造函数，全缺省的构造函数，编译器自己生成的默认函数。都称为默认函数。并且只能出现一种默认构造函数。不然将会出现下图的结果：

在这里插入图片描述

4.3 析构函数

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

以下代码为例：

class SList
{
public:
	SList()
	{
		a = (int*)malloc(sizeof(int)*4);
		assert(a);
		sz = 0;
		capacity = 4;
	}

	~SList()
	{
		free(a);
		a = NULL;
	}
	void SLPush(int x)
	{
		a[sz] = x;
		sz++;
	}
private:
	int* a;
	int sz;
	int capacity;
};
int main()
{
	SList l1;
	l1.SLPush(1);
	l1.SLPush(1);
	l1.SLPush(1);
 	return 0;
}

在这段代码中，编译器在程序结束时自动调用析构函数，进行对象的清理。

再来看一段代码：

class Time
{
public:
	~Time()
	{
		cout << "Time()" << endl;
	}
};

class Date
{
private:
	int _day;
	int _month;
	int _year;
	Time t;
};
int main()
{
	Date d1;
	return 0;
}

运行结果：
在这里插入图片描述

在这段代码中，我们显式定义了Time类的析构函数，而没有显式定义Date类的析构函数，但是，我们通过观察运行结果发现，创建的Date类对象在销毁是，调用了Time类的析构函数。这是为什么呢？首先，对于Date对象里的内置变量来说，它们是不需要析构函数的，程序结束时，系统会直接回收其空间。对于自定义成员，编译器会调用Date类的析构函数，而Date类的析构函数则会调用Time类的析构函数。Date类的析构函数是未显式定义的，因此，编译器会为Date类创建一个默认的析构函数。

注意：
如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

4.4 拷贝构造函数

4.4.1 什么是拷贝构造

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类的类型对象创建新对象时由编译器自动调用。拷贝构造是构造函数的一种重载。而且拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错。

4.4.2 为什么在传参数时不能传值

在函数进行传值调用时，会将实参进行拷贝形成形参。在拷贝构造中，若传值，则会引发对象的拷贝。因为，形参需要对实参拷贝。也就是说，我们本是想拷贝一个对象，但是在传值传参的时候又需要去拷贝实参这个对象，又绕了回去，所以，最终会形成死递归。

示例代码如下：


class Date
{
public:
	Date()
	{

	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void modeify(int day)
	{
		_day = day;
	}
private:
	int _day=1;
	int _month=2;
	int _year=3;
};

int main()
{
	Date d1;
	Date d2(d1);
	d1.modeify(2);
	//Date d2(d1);
	return 0;
}

若是将&去掉则为传值，运行结果如下：

在这里插入图片描述

若没有显式定义，则编译器也会生成默认拷贝构造函数，默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

再来看一段代码：

class SList
{
public:
	
	SList()
	{
		a = (int*)malloc(sizeof(int) * 4);
		sz = 0;
		capacity = 4;
	}

	~SList()
	{
		free(a);
		a = NULL;
	}
	void SLPush(int x)
	{
		a[sz] = x;
		sz++;
	}
private:
	int* a;
	int sz;
	int capacity;
};
int main()
{
	SList l1;
	l1.SLPush(1);
	l1.SLPush(2);
	l1.SLPush(3);
	SList l2(l1);
	return 0;
}

在这段代码中，我们的拷贝构造函数是编译器自动生成的，运行这段代码后我们发现程序崩溃了，但将析构函数屏蔽后，发现能够运行。这是为什么呢？
因为默认拷贝是值拷贝，原封不动的将l1中的内容拷贝到l2中，所以，l1与l2两个对象的a，共同指向一片空间。因此，当程序结束时，析构函数先将l2的资源清理掉，当再清理l1的资源是会发现a已将被清理，一块空间多次被清理，程序便会崩溃。
类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，并且需要用到深拷贝。以后我们会说到。

4.5 赋值运算符重载

4.5.1 运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。其函数名为：operator后面接需要重载的运算符号。
我们以==这个运算符为例，代码如下：

class Date
{
public:
	Date(int year = 2023, int month = 5, int day = 6)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	bool operator==(const Date& d2)
	{
		return _year == d2._year && _month == d2._month
			&& _day == d2._day;
    }
private:
	int _day;
	int _month;
	int _year;
};
int main()
{
	Date d2;
	Date d1;
	cout << (d1 == d2) << endl;
	return 0;
}

在这段函数中，我们将==赋予特殊的含义，使得其能够用作类之间的比较。
运算符重载还需注意以下这些：

  1. 不能通过连接其他符号来创建新的操作符：比如operator@。
  2. 重载操作符必须有一个类类型参数。
  3. 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义.
  4. 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this。
  5. .* :: sizeof ?: . 注意以上5个运算符不能重载。

4.5.2 赋值运算符

我们来看一段代码：

class Date2
{
public:
	//构造函数，负责初始化
	Date2(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//赋值运算符重载
	Date2& operator=(const Date2& d)
	{
		if(this!=&d)
		{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
		}
	}
	//拷贝构造
	Date2(const Date2& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	//打印
	void Print()
	{
		cout << _year << endl;
		cout << _month << endl;
		cout << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date1 d2;
	Date1 d1;
	//cout << (d1 == d2) << endl;
	Date2 d3(2023,4,4);
	//Date2 d4(2023,5,5);
	//d3 = d4;//赋值
	Date2 d4(d3);//拷贝	
	Date2 d5 = d3;//拷贝
	d3.Print();
	d4.Print();
	return 0;
}

在上段代码中，赋值运算符的重载函数，我们用引用返回来提高了代码的效率，并且避免了自己给自己赋值的情况。并且要区分拷贝与赋值。拷贝是用已存在的类型的对象，去创建一个相同的新对象；而赋值是两个都已经存在的对象，一个给另一个赋值。要注意的是，Date2 d5 = d3;不是赋值，而是拷贝。
赋值运算符只能重载成成员函数，不能重载成全局函数，因为当类中为显式定义赋值运算符重载时2，编译器会默认生成一个。就会发生冲突吧。
注意：编译器默认生成的赋值运算符重载是以值的方式逐字拷贝。其中内置类型是直接拷贝，而自定义是调用其对应的赋值运算符重载完成。但是如果涉及到资源的管理，就不能用默认生成的赋值运算符重载，而得用到深拷贝。

4.5.3 前置++与后置++

我们来直接看代码：

class Date2
{
public:
	//构造函数，负责初始化
	Date2(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//赋值运算符重载
	Date2& operator=(const Date2& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}
	//拷贝构造
	Date2(const Date2& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	//打印
	void Print()
	{
		cout << _year << endl;
		cout << _month << endl;
		cout << _day << endl;
	}

	//前置++
	Date2& operator++()
	{
		_day += 1;
		return *this;
	}

   //后置++
	Date2 operator++(int)
	{
		Date2 tmp(*this);
		_day++;
		return tmp;
	}
	
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date2 d3(2023,4,4);
	Date2 d4(2023,5,5);
	d4=++d3;
	d4 = d3++;
	d4.Print();
	d3.Print();
	return 0;
}

运行结果：
在这里插入图片描述
通过对运行结果的观察，我们发现代码符合我们的预期，但要注意的是为了区别前置与后置，我们在后置时需要加一个整型的参数，这个参数的作用就是为例区别前置与后置，再无其他作用。
还要注意的是前置我们使用的是引用做返回值，因为*this指向的对象不会在函数结束后销毁。而，后置中在函数内定义的对象，会在函数结束后也销毁，因此不能用引用做返回值。

4.6 取地址及其const 取地址重载

4.6.1 const 成员

在讲取地址重载前，我们先需要补充const 成员的相关知识。

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

我们来看下面这段代码：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}

	void Print()const
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023, 5, 9);
	const Date d2(2023, 5, 5);
	d1.Print();
	d2.Print();
	return 0;
}

当我们讲const成员函数屏蔽后，结果如下：
在这里插入图片描述
造成这样的结果是由于d2的类型为const Date,而要是没有const修饰成员函数Print()，则其隐含的this指针的类型为Date* ，const Date*—>Date* 是权限的扩大，是不允许的，因此会报错；权限的缩小和平移是允许的。

4.6.2 取地址及其const 取地址重载

我们来看代码：

Date* operator&()
	{
		return this;
	}

	const Date* operator&()const
	{
		return this;
	}

上述两个重载函数，一般是不需要我们去写的，由编译器默认生成。若我们不想让别人获取某些内容，才需要我们去写。

五，再谈构造函数

5.1 构造函数体赋值

我们在前面所写的普通构造，虽然这种构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

5.2 初始化列表

初始化列表才真正意义具有初始化功能，并且，初始化列表是构造函数的一部分。未显式定义时，会默认生成。

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

还需要注意的是：

  1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
  2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
    引用成员变量
    const成员变量
    自定义类型成员(且该类没有默认构造函数时，有参数的构造都不是默认构造)

来看以下代码：

class A
{
public:
	A(int a)//带有形参的构造函数，不是默认构造函数
		:t(a)
	{}
private:
	int t=1;
};
class B
{
public:
	B(int i, int& j)
		:a(j)
		, b(i)
		, _t(i)//若自定义类型会自动调用其默认构造
	    {}	  //但由于上述显式的构造为非默认构造，则无法调用
	
private:
	int& a;
	const int b;
	A _t;

};
int main()
{
	int n = 10;
	B b1(3,n);
	return 0;
}

注意：初始化列表的初始化顺序是类中成员变量声明的顺序。

5.3 explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。
看以下这段代码：

class Date
{
public:
	Date(int year,int month=5,int day=9)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
	
	void Print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1 = 2023;
	d1.Print();
	return 0;
}

在这段代码中，我们注意到Date d1 = 2023;这样一句奇怪的代码，那么实际这句代码执行了什么呢？
在这句代码中，编译器自动将整型转换为Date类对象，实际等同于下面的操作：

Date d1(2023);
	//或者
	Date tmp(2023);
	Date d1= tmp;

就是先用2023构造一个匿名的对象，然后再进行拷贝构造，但是，大多数编译器为了效率，会进行优化，就变为直接用2023构造。
加上explicit后，这种隐式转换就不能用了。

六，static成员

什么是static成员：
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。且静态成员变量一定要在类外进行初始化。

来看以下代码：

class A
{
public:
	A()
	{
		_count++;
		cout << "A()" << endl;
	}

	A(const A& d)
	{
		_count++;
		cout << "A(const A&d)" << endl;

	}

	~A()
	{
		_count--;
		cout << "~A()" << endl;

	}

	static int Get_count()
	{
		return _count;
	}
private: 
	int _a;
	static int _count;
};

int A::_count = 0;
void func()
{
	 A d3;
}

int main()
{
	A d1;
	A d2(d1);
	func();
	cout <<A::Get_count() << endl;
	return 0;
}

运行结果：
在这里插入图片描述

static成员特性：

  1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。
  2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明。
  3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问。
  4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员。
  5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制。

七，友元

来看下面这段代码：

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
//重载运算符<<
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << " " << d._month << " " << d._day << endl;;
	return _cout;
}
int main()
{
	Date d1(2023, 5, 11);
	cout << d1 << endl;
	return 0;
}

如果将<<的重载函数定义为成员函数，由于cout的输出流对象和隐含的this指针会抢占第一个参数的位置。因此不能这样定义，只能将重载函数定义在类外，但是，定义在类外后将无法访问私有成员变量，就有了友元函数，在类中将函数声明为友元函数，就能在类外访问类中的私有变量。

通过上述代码，我们能够有以下总结：

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

在这里插入图片描述

/
在这里插入图片描述

运行结果：

在这里插入图片描述

在上述图中，我们在类A中将Date声明为友元类，则在Date类中就可以访问A类中的私有成员。

友元类还要注意下述说明：

  1. 友元关系是单向的，不具有交换性。
    比如上述Time类和Date类，在A类中声明Date类为其友元类，那么可以在Date类中直接访问Time
  2. 类的私有成员变量，但想在A类中访问Date类中私有的成员变量则不行。
  3. 友元关系不能传递
    如果B是A的友元，C是B的友元，则不能说明C时A的友元。
  4. 友元关系不能继承，在继承位置再给大家详细介绍

八，内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外
部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

  1. 内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
  3. sizeof(外部类)=外部类，和内部类没有任何关系。
进击的1++
关注
专栏目录
C++初阶：类和对象
weixin_36194037的博客
09-21 354
C++初阶：类和对象
C++初阶：STL之vector类模板
weixin_36194037的博客
12-14 1548
C++初阶：STL之vector类模板
C++初阶——类与对象（上篇）
qq_55890817的博客
10-30 1715
与C语言中存在的结构体不同，在类中，不仅可以定义变量，还可以定义函数。在C++中，使用class作为定义一个类的关键字。class body;//由成员变量和成员函数组成。class作为定义类的关键字，className为类的名字，{}中为类的主体，注意类定义结束后存在一个不可省略的分号。类体中的内容称为类的成员，类中的变量称为类的属性或者成员变量；类中函数被称为类的方法或者成员函数。成员函数的声明和定义全部放在类体中，需要注意的是，这种写法会导致编译器将成员函数当作内联函数处理。
【C++初阶】类与对象（上）
旋律 | 话语 | 色彩 | 情景
04-22 724
【C++初阶】类与对象（上）
C++初阶之 类和对象！
2301_81772249的博客
09-15 385
class为定义类的关键字,class后面为类的关键字,{}里为类的主体,注意类定义结束后面不能省略分号类中的变量为成员变量,类中的函数为成员函数为了区分成员变量,一般都在成员变量前面加一个_c++中,struct也可以定义类,c++中兼容c的struct用法,明显的变化是struct 可以定义函数,一般情况下我们还是用class定义类public://成员函数perror("malloc申请失败!");return;top = 0;//...扩容int Top()
C++初阶之类和对象
yueqing8的博客
07-30 284
C++面向对象的三大特点：封装、继承和多态。C++认为万事万物结尾对象，对象上有其属性和行为。
C++初阶讲解—运算符重载汇总+实例（上）
m0_57781768的博客
11-17 1482
运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
【C++初阶】类与对象（一）
weixin_61654591的博客
04-16 399
/ 类体：由成员函数和成员变量组成// 一定要注意后面的分号class为C++的关键字，代表一个类，class后边加上这个类的名字，在类体内定义函数和变量，这点和C语言是不同的，并且不能省略括号外边的分号。类体中内容称为类的成员：类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者成员函数。声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
＜C++初阶之路＞解析c和c++中的const关键字
m0_62171658的博客
05-17 1138
解析c和c++中的const关键字
C++——类和对象初阶讲解完整版（类的引入、类的定义、类的作用域、类的实例化、类访问限定符及封装、类成员函数的this指针、析构函数、构造函数、拷贝构造函数、赋值操作符重载、类的静态成员......）
weixin_53811859的博客
12-01 1854
家人们，百闻不如一见，百见不如一品啊！三万字超详细的C++类和对象讲解你值得拥有！
p4:cmu 15213/15513 csapp 深入理解计算机系统（寄存器、标志位/条件码、set指令、大端法小端法、逻辑左右移和算数左右移、字长概念）
shanshan的博客
11-11 496
可以简单记成，setg表示set greater，但是机器指令的参数顺序与我们习惯的顺序不同，机器指令是从右到左比较的。标志位都是一位，他们不是你直接设置的，而是计算机的算术指令自己设置的。在这里是零拓展的意思，将al的一字节的全0拓展为4字节，左边都补0。综上，机器指令的流程是，比较两个数，得到一字节的0或1，然后根据返回类型的字长要求，拓展为相应位数的0或1。这里setg指令根据sf条件码，假设为0，（说明y>x），那么最低位的单个字节也都设为0。将单个寄存器的单个字节根据条件码的值设为1或0。
C++——智能指针
Wangx_wang的博客
11-12 962
介绍了几种智能指针的不同和实现思路以及循环引用的问题
STL之vecor的使用(超详解)
2302_80220709的博客
11-11 777
如果发生的异地扩容，这时的迭代器就不在指向原来的空间，而就指向一块释放的内存，我们一旦继续访问就会报错，这种现象我们称为迭代器失效。指定位置插入，要注意的是这里不再像string一样，用的size_t 的pos，vector虽然也可以用下标访问，但是为了承接后面STL其他不支持下标访问的容器，所以这边的pos用的是迭代器类型。下面我们开始研究他的使用，为了能够更好的测试，我们先实现一个打印容器元素的函数，vector底层是数组，所以有三种访问方式：下标访问、迭代器访问、范围for（本质也是迭代器）
c++中，头文件包含iostream.h和`＜iostream＞`的差别
南东先生
11-11 388
`iostream.h` 和`` 包含的是同一个文件，二者在功能上没有差别,只是写法不同。使用``是C++标准推荐的方式。
TI毫米波雷达（五）—— chirp
最新发布
slyywd的博客
11-14 759
TI的毫米波雷达可以通过定义chirp配置文件来控制一帧中的chirp参数，而且可以在chirp RAM中修改这些配置文件。Chirp配置文件可以作为基础的chirp时序模板，用来生成参数各异的chirp。TI的毫米波雷达可以接收四个不同的chirp配置文件，但是chirp可配置RAM中可以预编程512个独特的chirp。每个chirp都可以引用四个配置文件之一，然后按需要进行细调。一个帧由chirp可配置RAM中起始索引到结束索引间的chirp序列组成，最大可循环255次。
C++ 内存分布及 new , delete 分配问题( ~~~ 面试重要 ~~~)
GAOSHOUCYUYAN的博客
11-10 830
本篇文章笔者将会对 C++ 中的内存问题简单的讲解 , 同时对 new , delete 的面试题进行重点讲解.以上就是本篇的内容 , 希望读者认真领会.
C++ 编程基础（5）类与对象 | 5.7、友元
个人技术博客
11-14 748
C++中的友元类与友元函数是一种强大的工具，它们允许程序员在保持类封装性的同时，实现对类内部数据的直接访问。然而，在使用时应谨慎考虑其对封装性、安全性和维护性的影响。只有在确实需要时才使用友元类和友元函数，以避免引入不必要的复杂性和潜在问题。
3195. 有趣的数-13年12月CCF计算机软件能力认证（组合数）
m0_73939047的博客
11-10 201
13年12月CCF计算机软件能力认证（组合数）
【代码随想录day29】【C++复健】134. 加油站；135. 分发糖果；860.柠檬水找零；406. 根据身高重建队列
yumenohimiko的博客
11-14 605
感觉贪心的题真的很考验一个人的智商，而我，碰巧没有。134. 加油站偷看了解析思路，但依然因为一个低级失误导致被卡了很久... 并且写出来的代码也非常的麻烦，主要体现在我每到一个新节点，就必须求证似的让iter走完一整圈才算结束，但卡哥的方法一个for循环就结束了。卡哥的思路也相当的清晰：简单来说就是当你一圈下来：1 如果和小于0，那么说明无论如何无解，也不用往后再看了。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

进击的1++

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值