类与对象(中)

最新推荐文章于 2025-05-03 18:38:58 发布
最新推荐文章于 2025-05-03 18:38:58 发布
阅读量214 收藏
点赞数 1
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Ryujianli/article/details/129016212
版权

文章目录

类与对象(中)

1.类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

在这里插入图片描述

2. 构造函数

2.1 概念

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout <<_year<< "-" <<_month << "-"<< _day <<endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1,d2;
	d1.Init(2018,5,1);
	d1.Print();
}

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

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

2.2 特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：

  1. 函数名与类名相同。
  2. 无返回值。
  3. 对象实例化时编译器自动调用对应的构造函数。
  4. 构造函数可以重载。
class Date
{
public:

    //构造函数，与类名同名，无返回值
	Date()        //无参构造函数
	{
		_year = 0;
		_month = 1;
		_day = 1;
	}

	//构造函数支持函数重载
	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, 1, 19);    //调用带参构造函数

	return 0;
}

注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明

错误写法: Date d3();

上面写法, 声明了d3函数，该函数无参，返回一个日期类型的对象

2.2.5
  1. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
class Date
{
public:
	void Print()
	{
		cout<< _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1; 
    d1.Print();
	return 0;
}

运行结果:

在这里插入图片描述

  1. 关于编译器生成的默认成员函数，有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用
2.2.6

在C++里面把类型分为两类：内置类型（又叫基本类型）、自定义类型

内置类型：内置类型就是语法已经定义好的类型，比如int/char…
自定义类型：struct/class定义的类型

编译器处理规则:

内置类型成员不处理

自定义类型成员, 调用它的构造函数

class Stack
{
public:
	Stack()
	{
		cout << "Stack()" << endl;

		_a = nullptr;
		_size = _capacity = 0;
	}
	
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_size = _capacity = 0;
	}

private:
	int* _a;
	int _size;
	int _capacity;
};
class MyQueue {
public:
	void push(int x) {

	}

	Stack _pushST;
	Stack _popST;
};
int main()
{
	MyQueue q;

	return 0;
}

对于自定义类型MyQueue 不用自己去初识化, 编译器会自动生成一个默认构造函数去初识化

运行结果:

在这里插入图片描述

补丁

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。

class Date
{
public:
	void Print()
	{
		cout<< _year << "-" << _month << "-" << _day << endl;
	}
private:
    //声明位置给缺省值
	int _year=1;
	int _month=1;
	int _day=1;
};
int main()
{
	Date d1;
	d1.Print();

	return 0;
}

运行结果:

在这里插入图片描述

2.2.7
  1. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。
class Date
{
public:
	Date()
	{
		_year = 1900;
		_month = 1;
		_day = 1;
	}
    
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;

	return 0;
}

编译报错: 类 “Date” 包含多个默认构造函数

语法上无参的和全缺省的可以同时存在，但是无参调用时会出现问题，不知道要调用哪个, 存在歧义

推荐写法:

//使用缺省参数(全缺省或者半缺省)实现函数重载(推荐使用)
Date(int year = 0, int month = 1, int day = 1)
{
	_year = year;
	_month = month;
	_day = day;
}

3.析构函数

3.1 概念

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

3.2 特性

析构函数是特殊的成员函数，其特征如下：

  1. 析构函数名是在类名前加上字符 ~。
  2. 无参数无返回值类型。
  3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
class Date
{
public:
	
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	return 0;
}

运行结果:

在这里插入图片描述

3.2.5
  1. 如果我们不写析构函数，编译器会自动生成默认析构函数，它对内置类型的成员变量不做处理(但是对于某些内置类型，比如malloc出来的需要我们自己析构), 对自定义类型的成员变量会调用它的析构函数。

编译器处理规则:

内置类型成员不处理

自定义类型成员, 调用它的析构函数

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(capacity * sizeof(int));
		if (_a == nullptr)
		{
			cout << "malloc failed\n" << endl;
			exit(-1);
		}
		_capacity = capacity;
		_top = 0;
	}

	~Stack()
	{
		//_a是内置类型，但是我们需要自己析构
		free(_a);
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

// 两个栈实现一个队列
class MyQueue {
public:
	// 默认生成的构造函数和析构函数会对自定义类型成员调用他的默认构造函数和析构函数
	void push(int x) {

	}
private:
	Stack pushST;
	Stack popST;
};
int main()
{
	MyQueue q;
	return 0;
}
3.2.6
  1. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类； 有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

4. 拷贝构造函数

4.1 概念

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

4.2 特征

特征1, 2

拷贝构造函数也是特殊的成员函数，其特征如下：

  1. 拷贝构造函数是构造函数的一个重载形式。
  2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用
对比传值传参和引用传参
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	Date(Date d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};

//传值传参
void Func1(Date d)
{

}

// 传引用传参
void Func2(Date& d)
{

}
int main()
{
	Date d1(2023, 2, 3);

	Func1(d1);
	Func2(d1);
    
	return 0;
}

调试:

传值传参

调用Func1函数

在这里插入图片描述

F11进入函数，我们会发现，先去调用了拷贝构造函数

在这里插入图片描述

然后才调用Func1函数

在这里插入图片描述

说明传值传参时，将实参d1传递给形参d，就是用对象d1去构造对象d，会调用拷贝构造函数(传值传参会调用拷贝构造函数)

引用传参

调用Func2函数

在这里插入图片描述

F11进入函数，我们会发现，直接调用Func2函数

在这里插入图片描述

说明引用传参时，不会调用拷贝构造函数

拷贝构造函数参数是传值方式

拷贝构造函数参数是传值方式时, 会引发无穷递归的问题

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	Date(Date d)             //错误写法：编译报错，会引发无穷递归
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
    
private:
	int _year;
	int _month;
	int _day;
};

// 传值传参
// 内置类型，编译器可以直接拷贝
// 自定义类型的拷贝，需要调用拷贝构造
int main()
{
	Date d1(2023, 2, 3);
	Date d2(d1);            // Date d2(d1)和Date d2 = d1 语句意思都是将d1的值拷贝给d2
	Date d2 = d1;

	return 0;
}

在这里插入图片描述

在这里插入图片描述

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

默认的拷贝构造函数：

对于内置类型成员变量，按照字节序拷贝(值拷贝，或者浅拷贝)

对于自定义类型成员变量，会调用它的拷贝构造函数

那么是不是意味着在任何情况下都可以不写拷贝构造函数呢?

不是的

定义了两个栈，实现st1拷贝到st2， 栈中的top和capacity会按照字节序拷贝, 可是两个栈中的两个指针指向同一块空间时，当两个对象销毁时，自动调用析构函数，两次析构同一块空间是存在问题的，这时候就需要我们自己来实现该类的拷贝构造函数(实现该指针变量的深拷贝，重新开辟空间，两个指针变量指向不同的空间，但是空间内的东西是一样的)。

在这里插入图片描述

自己写拷贝构造函数的情况

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以； 一旦涉及到资源申请时，则拷贝构造函数是一定要写的 ,否则就是浅拷贝。

5.赋值运算符重载

5.1 运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

注意:

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

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

	int _year;
	int _month;
	int _day;
};
//这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
bool operator==(const Date& d1, const Date& d2)
{
	return d1._year == d2._year
		&& d1._month == d2._month
		&& d1._day == d2._day;
}
int main()
{
	Date d1(2023, 2, 3);

	Date d2 = d1;

	cout << (d1 == d2) << endl;

	return 0;
}

上面的写法，将成员变量设置成了public，这样在类外面就能进行访问，但是这样破坏了封装性

将运算符重载函数写到类里面

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

    //bool operator==(Date* this, const Date& d2)
    //这里需要注意的是，左操作数是this(一个隐藏的形参this指针)，指向调用函数的对象
	bool operator==( const Date& d2)
	{
		return _year == d2._year
			&& _month == d2._month
			&& _day == d2._day;
	}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023, 2, 3);

	Date d2 = d1;

	cout << (d1 == d2) << endl;

	return 0;
}

5.2 赋值运算符重载

1. 赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义

1.1 参数是传值方式
class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
    //拷贝构造
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;

		cout << "Date(const Date& d)" << endl;
	}

	//参数是传值方式
	Date& operator=(const Date d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023,2,3);
	Date d2(2025,8,3);

    d1 = d2;
	return 0;
}

调试:

在这里插入图片描述

F11进入函数，我们会发现，先去调用了拷贝构造函数去传参

在这里插入图片描述

在这里插入图片描述

传参完成后再去赋值重载

在这里插入图片描述

1.2 传值返回
class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
    //拷贝构造
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;

		cout << "Date(const Date& d)" << endl;
	}

	//传值返回
	Date operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023,2,3);
	Date d2(2025,8,3);

    d1 = d2;
	return 0;
}

调试:

在这里插入图片描述

首先进入赋值重载函数

在这里插入图片描述

然后在返回时，进入拷贝构造函数(传值传参需要调用拷贝构造)

在这里插入图片描述

调用完拷贝构造函数后再返回

在这里插入图片描述

综上:

参数类型是引用, 传引用返回可以提高效率

注意: 如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

1.3 检测是否自己给自己赋值 + 1.4 返回*this
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	Date& operator=(const Date& d)
	{   //检查是否自己给自己赋值
		if (this != &d)               //左操作数地址 == 右操作数的地址(别名的地址)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		 return *this;                //返回*this ：支持连续赋值
	}
private:

	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023, 2, 3);
	Date d2(2024, 8, 3);
	Date d3(2064, 8, 3);

	d1 = d2= d3;

	return 0;
}
2. 赋值运算符只能重载成类的成员函数不能重载成全局函数
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    
	int _year;
	int _month;
	int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=( Date& d1, const Date& d2)
{
	  d1._year = d2._year;
	  d1._month = d2._month;
	  d1._day = d2._day;
}

int main()
{
	Date d1(2023, 2, 3);
	Date d2(2024, 8, 3);

	d1 = d2;

	return 0;
}
// 编译失败：
// error : “operator =”必须是非静态成员

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故 赋值运算符重载只能是类的成员函数。

3. 默认生成赋值运算符重载

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

下面的代码, 可以不写赋值重载, 编译器会生成一个默认赋值运算符重载

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

	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023, 2, 3);
	Date d2(2024, 8, 3);
	Date d3(2064, 8, 3);

	d1 = d2= d3;           //编译器会生成一个默认赋值运算符重载

	return 0;
}

那么是不是意味着在任何情况下都可以不写赋值运算符重载函数呢?

不是的

定义了两个栈，实现s1拷贝到s2， 默认的赋值重载会将s1内容原封不动的拷贝到s2, 栈中的top和capacity会按照字节序拷贝, 但是会使两个栈中的两个指针指向同一块空间，(1)s2原来的空间消失存在内存泄露 (2)当两个对象销毁时，s1和s2共享一块空间, 编译器自动调用析构函数，两次析构同一块空间是存在问题的，这时候就需要我们自己来实现该类的赋值运算符重载函数

在这里插入图片描述

自己写赋值运算符重载函数的情况

注意：类中如果没有涉及资源申请时，赋值运算符是否实现都可以； 一旦涉及到资源申请必须要实现。

5.3 前置++和后置++重载

前置++：
返回+1之后的结果
this指向的对象函数结束后不会销毁，故以引用方式返回提高效率

后置++：
后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1, 而temp是临时对象，因此只能以值的方式返回，不能返回引用

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	Date& operator++()
	{
		_day += 1;
		return *this;    //*this是调用该成员函数的对象, 在函数调用结束时不会销毁
	}

	Date operator++(int)
	{
		Date temp(*this);
		_day += 1;
		return temp;
	}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d;
	Date d1(2022, 1, 13);
	d = d1++;              // d: 2022,1,13 d1:2022,1,14
	d = ++d1;              // d: 2022,1,15 d1:2022,1,15
	return 0;
}

5.4 区分拷贝构造和赋值重载

int main()
{
	Date d1(2023, 2, 3);
	Date d2(2024, 8, 3);
	Date d3(2064, 8, 3);

	Date d5=d1;          //拷贝构造
	d1 = d2;             //赋值重载

	return 0;
}

拷贝构造：用一个已经存在的对象初始化一个马上实例化的对象

赋值重载：两个已经存在的对象之间进行赋值拷贝

6.const成员

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

在这里插入图片描述

6.1 间接的const对象

class A
{
public:
	void Print() const
	{
		cout << _a << endl;
	}
private:
	int _a = 10;
};

void Func(const A& x)
{
	x.Print();        //上面的Print函数没有加const会报错, 这里是间接的const对象
}
int main()
{
	A aa;
	aa.Print();      //权限的缩小
	
	Func(aa);        //aa不是const修饰的对象,间接的const对象

	return 0;
}

6.2 思考题

思考：可以参考C++ 入门博客中的权限问题, 链接:

  1. const对象可以调用非const成员函数吗？
    不可以，权限放大了。const对象（this指针的类型是：const 类类型* this）调用非const成员函数（形参this指针的类型是：类类型 this），指针的权限是指前面。

  2. 非const对象可以调用const成员函数吗？
    可以，权限缩小了，非const类型指针传递给const类型指针。

  3. const成员函数内可以调用其它的非const成员函数吗？
    不可以，权限放大了

  4. 非const成员函数内可以调用其它的const成员函数吗？
    可以，权限缩小了

总结:

权限可以缩小和保持, 权限不能放大

7. 取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

class AA
{
public:
	//自己实现的取地址操作符重载
	AA* operator&()
	{
		return this;
		//return nullptr;        //不希望别人获取对象的地址
	}

	const AA* operator&() const //const AA* operator&(const AA* const this)
	{
		return this;
	}
};

int main()
{
	Date d1;
	d1.Print();

	const Date d2;
	d2.Print();

	AA aa1;
	cout << &aa1 << endl;     //opeartor&(&aa1)

	const AA aa2;
	cout << &aa2 << endl;

	return 0;
}

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

python中的类和对象
Python全栈系列
08-16 1万+
面向对象和面向过程二者相辅相成，并不是独立的,解决复杂问题，通过面向对象便于我们从宏观上把握事物之间复杂关系，方便我们分析整个系统；具体到微观操作，仍然使用面向过程来处理
Java 类与对象 -- Java 语言的类与对象、构造器、static、final、包和 JAR
栗筝i的博客
06-11 4357
本篇文章我们将深入了解 Java 语言中的类与对象，探讨构造器、`static`、`final`、包和 JAR 文件。这些概念是面向对象编程的核心，对于理解和掌握 Java 至关重要。
Java类和对象 详解（一）
热门推荐
wei_zhi的博客
10-06 18万+
一、面向对象简述面向对象是一种现在最为流行的程序设计方法，几乎现在的所有应用都以面向对象为主了，最早的面向对象的概念实际上是由IBM提出的，在70年代的Smaltalk语言之中进行了应用，后来根据面向对象的设计思路，才形成C++，而由C++产生了Java这门面向对象的编程语言。但是在面向对象设计之前，广泛采用的是面向过程，面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主，实
Java中类与对象的关系与区别
scbiaosdo的博客
04-12 1万+
什么是类？类就是具备某些共同特征的实体的集合，它是一种抽象的数据类型，它是对所具有相同特征实体的抽象。在面向对象的程序设计语言中，类是对一类“事物”的属性与行为的抽象。什么是对象？对象就是一个真实世界中的实体，对象与实体是一一对应关系的，意思就是现实世界的每一个实体都是一个对象，所以对象是一个具体的概念。类是对象的一个集合，对象是类的实例。而对象的产生在Java中是使用new来实现的。做一个比方老...
Java 中的类与对象
学习笔记
06-02 3743
类是构造对象的模板，由类构造（construct) 对象的过程称为创建类的实例 (instance)。 对象中的数据称为实例域（instance field)， 操纵数据的过程称为方法（method)。 对于每个特定的类实例（对象）都有一组特定的实例域值，这些值的集合就是这个对象的当前状态（ state )。 1. 封装性 封装性：将数据和对数据的操作封装起来，对象状态（属性）由这...
【C++】类与对象（引入）
Lin_Alpaca的博客
02-22 2166
类与对象的入门介绍✨✨
C++类和对象详解
少说，多做。
05-08 4073
创建对象 两种创建对象的方式：一种是在栈上创建，形式和定义普通变量类似；另外一种是在堆上使用 new 关键字创建，必须要用一个指针指向它，读者要记得 delete 掉不再使用的对象。 通过对象名字访问成员使用点号.，通过对象指针访问成员使用箭头->，这和结构体非常类似。 成员变量和函数 类可以看做是一种数据类型，它类似于普通的数据类型，但是又有别于普通的数据类型。类这种数据类型是一个包...
Python的类属性与对象属性的区别
西门一刀的博客
11-29 2712
Python的类属性与对象属性的区别 命名规则： 1.1 类属性由类创建，命名规则为类名.属性名 1.2 对象属性由对象创建，命名规则为对象名.属性名 调用方法： 2.1 类属性由类调用 2.2 对象属性由对象调用 调用规则：有对象属性时，类属性无法调用 可以动态添加，删除对象属性；添加后，对象属性只针对当前对象生效，删除后，再次调用会调用类属性 class Person(object): # 这里的属性实际上属于类属性(用类名来调用) name = "person" def _
Java类和对象练习题
xiao梁同学的博客
11-06 1932
类和对象的练习题
类和对象的创建
qq_41982346的博客
11-21 1861
类和对象的创建
java对象与类实例java对象与类实例java对象与类实例java对象与类实例java对象与类实例java对象与类实例java
06-22
java对象与类实例java对象与类实例java对象与类实例java对象与类实例java对象与类实例java对象与类实例java对象与类实例java对象与类实例java对象与类实例java对象与类实例java对象与类实例java对象与类实例java对象...
面向对象中类与类之间的关系
ULTRAmanTAROACE的博客
04-25 1272
类与类之间的关系是面向对象编程（OOP）中的核心概念之一，它们描述了不同类之间的相互作用和依赖方式。关联、聚合、组合、依赖
C++类：类中的静态属性和函数、常量函数与常对象、类在内存中的存储
qq_41657077的博客
03-23 2090
静态属性 静态成员包括静态成员属性、静态成员函数。 一个属性一旦设置为静态，那么整个程序中就独其一份。 如上所示，之前p.m_A的值是100。使用p2.m_A更改了该值为200后，即使再用p.m_A去调用，结果仍是200。 静态属性会在代码运行前的编译阶段就生成并保持存在全局区。静态属性和静态成员函数都不算在类内，都是保存在别的区域(全局区)。 静态属性必须要有一个初始值，可以在类内声明，类外初始化。 类内声明： 类外初始化： Person::表示这个变量是在person作用.
Python面向对象-类与对象
Hello大家好，我是Dream，如果帮得到你，那我深感荣幸！想进粉丝福利群及免费送书群，直接私信我拉你。交流学习、商务合作：https://bbs.youkuaiyun.com/topics/614347534
08-18 6万+
类方法是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以’cls’作为第一个参数的名字，就最好用’cls’了），能够通过实例对象和类对象去访问。如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。
std::print 和 std::println
janeqi1987的专栏
04-28 1029
std::print和是 C++23 新增的格式化输出函数，旨在替代传统的std::cout链式调用。它们基于实现，支持类型安全的格式化字符串，语法更简洁，性能更优15。直接输出到stdout（默认）或指定的流。自动在输出末尾添加换行符。支持与相同的格式化语法（如{}占位符）。
深入理解C语言中的整形提升与算术转换
qinyuz的博客
05-01 618
在C语言中，整形提升（Integer Promotion）是一个重要但容易被忽视的概念。它指的是在表达式中，任何小于。是无符号char，赋值-1会转换为255（0xFF）长度为标准操作数长度，使用标准长度可以提高运算效率。都是有符号char，值为-1（内存表示：0xFF）：符号扩展为0xFFFFFFFF（即-1）：零扩展为0x000000FF（即255））操作数在使用前都会被自动转换为普通整型。：确保不同大小的整型在运算时有一致的表现。有符号类型：高位补符号位。无符号类型：高位补0。是2字节，所以前两个。
STL之list容器
Laydya的博客
05-03 775
1.list的底层是双向链表结构，双向链表中的每个元素在互不相关的独立结点中，在结点中通过指针指向前一个元素和后一个元素2.list是可以在常数范围内在任意位置的插入和删除的序列式容器，并且该容器可以前后双向迭代3.vector的优点：支持随机访问，间接的就支持了排序/二分查找/堆排序等缺点：1.头部和中部的插入效率低，需要挪动数据2.插入数据空间不够需要增容，增容需要开新空间，拷贝数据，释放旧空间list的优点：没有增容代价，且任意位置插入都是0（1）；
STL之vector容器
Laydya的博客
05-02 1184
1.vector是可变大小数组的容器2.像数组一样，采用连续的空间存储，也就意味着可以通过下标去访问，但它的大小可以动态改变3.每次的插入都要开空间吗？开空间就要意味着先开临时空间，然后在拷贝旧的到新的上面，在释放原来的，就时间而言，这是一个相对代价很高的任务；显然这是不行的，vector的分配策略：会分配一些而外的空间以适应可能的增长，例如我们平时说的以1.5或者2倍的方式增容，不同的库选择不同的策略权衡空间的使用和重新分配，以至于在插入一个元素时能在常数时间内插入；
游戏代码C
最新发布
2301_81771576的博客
05-03 360
以下将结合不同编程语言的特点及游戏开发中的实际应用，展示多种语言的游戏代码示例（以简单游戏为例，展示代码结构和逻辑差异）。3. Python/JavaScript/Lua：语法简洁，适合快速开发，代码量最少。Unity引擎集成度高，C#代码简洁但功能强大，适合快速开发跨平台游戏。1. C++：需手动管理资源（如字体加载），代码行数最多但性能最优。Lua语法极简，常用于游戏逻辑脚本（如《魔兽世界》插件）。1. C# + Unity（面向对象，适合跨平台开发）Python语法简洁，适合快速验证游戏逻辑。
C++入门：类与对象基础习题详解
C++ 类与对象是面向对象编程（Object-Oriented Programming, OOP）的基础概念，本文档主要针对初学者提供了一系列关于C++ 中类与对象的习题和解答。首先，我们来看填空题部分： 1. 在C++ 中，引入类定义的关键字是`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值