类与对象（下）

已于 2023-05-11 21:08:24 修改
阅读量79 收藏
点赞数 1
分类专栏： c++ c语言 文章标签： 算法 c++
于 2023-05-09 18:13:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wh9109/article/details/130574584
版权
c++ 同时被 2 个专栏收录
43 篇文章 1 订阅
订阅专栏
c语言
11 篇文章 0 订阅
订阅专栏

类与对象（下）

1. 再谈构造函数

在开始之前，我们先认识到，构造函数初始化有两种：构造函数体内赋值、初始化列表赋值

1.1 构造函数体赋值

在调用对象时，编译器通过调用构造函数来进行赋初值，如果没有构造函数编译器会调用默认构造函数（自动生成）

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

这里需要注意的时，再完成调用构造函数后，只能说是对语句进行了赋初值，不能称作为初始化，因为初始化只能初始化一次，而构造函数体内可以多次赋值。

1.2 初始化列表

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

class A
{
public:
	A(int a = 10)
	{ 
		_a = a;
	}
private:
	int _a;
};

class B
{
	//构造函数赋值
	B(int a, int ref)
	{
		_n = 0;
		ref = ref;
	}
private:
	A _aobj;  // 没有默认构造函数

	//特征：必须在定义的时候初始化
	int& _ref;  // 引用
	const int _n; // const 
};

int main()
{
	B bb1(10, 1);

	return 0;
}

在这里插入图片描述
因为引用和const只能初始化一次，如果放到构造函数内部就会进行多次的赋初值，所以这里就会报错

class A
{
public:

	//有默认构造
	A(int a = 10)
	{ 
		cout << "A(int a = 10" << endl;
		_a = a;
	}
private:
	int _a;
};

class B
{
public:

	//初始化列表：对象的成员定义的位置
	B(int a, int ref)
		//:_aobj(a)
		: _ref(ref)
		, _n(10)
	{}
private:
	A _aobj;  // 没有默认构造函数（自动调用自定义的）

	//特征：必须在定义的时候初始化
	int& _ref;  // 引用
	const int _n; // const 
};

int main()
{
	B bb1(10, 1);

	return 0;
}

在这里插入图片描述
在类里头声明一个内置类型，内置类型是不会被初始化的。

class B
{
public:

	//初始化列表：对象的成员定义的位置
	B(int a, int ref)
		//:_aobj(a)
		: _ref(ref)
		, _n(10)
		,_ x(2)
	{}

	//构造函数赋值
	//B(int a, int ref)
	//{
	//	_n = 0;
	//	ref = ref;
	//}
private:
	A _aobj;  // 没有默认构造函数（自动调用自定义的）

	//特征：必须在定义的时候初始化
	int& _ref;  // 引用
	const int _n; // const 
	
	//内置类型
	int _x;

	//在类里给值(给了缺省值就会用缺省值初始化)
	//int _x = 1;//这里1是缺省值，缺省值是给初始化列表的
	//如果在初始化列表初始化，就会直接用初始化列表的值来初始化
};

在这里插入图片描述
在这里插入图片描述
代码总结

class A
{
public:
	A(int a = 10)
	{ 
		cout << "A(int a = 10" << endl;
		_a = a;
	}
private:
	int _a;
};

class B
{
public:

	//初始化列表：对象的成员定义的位置
	B(int a, int& ref)
		:_aobj(a)
		, _ref(ref)
		, _n(10)
		,_x(2)
	{}

	//构造函数赋值
	//B(int a, int ref)
	//{
	//	_n = 0;
	//	ref = ref;
	//}
private:
	A _aobj;  // 没有默认构造函数（自动调用自定义的）
	//不是编译器生成的就是默认构造

	//不传参的都叫默认构造
	//全缺省、无参我们不写，编译器自动生成的都叫默认构造

	//特征：必须在定义的时候初始化
	int& _ref;  // 引用
	const int _n; // const 

	//int _x;

	int _x = 1;
};

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}

		_size = 0;
		_capacity = capacity;
	}

	void Push(const DataType& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};

class MyQueue
{
public:
	//我们不写我们的变量也会走初始化列表（调用无参）
	MyQueue()
	{}

	//如果显示初始化，也是可以的，这样的话就走自己写的初始化函数（调用有参）
	MyQueue(int capacity)
		:_pushst(capacity)
		,_popst(capacity)
	{}

private:
	Stack _pushst;
	Stack _popst;
};

int main()
{
	// 对象整体定义
	int n = 10;
	B bb1(10, n);

	MyQueue q1;
	MyQueue q2(100);

	return 0;
}

注意

  1. 每个成员变量在初始化列表中最多只能出现一次（初始化只能初始化一次）
  2. 类中的以下成员必须放在初始化列表位置进行初始化：
    2.1 引用成员变量
    2.2 const成员变量
    2.3 自定义类型成员（且该类没有默认构造函数时）

尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化

class Stack
{
public:
	Stack(int capacity = 10)
		:_a((int*)malloc(sizeof(int)*capacity))
		,_top(0)
		,_capacity(capacity)
	{
		if (_a == nullptr)
		{
			perror("malloc error");
			exit(-1);
		}

		//数组初始化
		memset(_a, 0, sizeof(int) * capacity);
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{

	Stack st1;
	return 0;
}

在这里插入图片描述
这里还需要注意的是，成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

class A
{
public:
	A(int i)
		:_a1(i++)
		,_a2(i++)
		,_a3(i++)
	{}
	void print()
	{
		cout << _a3 << "  " << _a2 << "  " << _a1 << endl;
	}
private:
	int _a3;
	int _a2;
	int _a1;
};

int main()
{
	int i = 0;
	A aa1(i);
	aa1.print();
	return 0;
}

在这里插入图片描述

在这里插入图片描述

1.3 explicit关键字

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

class A
{
public:
	A(int a)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& a)
	{
		cout << "A(const int& a)" << endl;
	}

private:
	int _a;
};

int main()
{
	A aa1(1);
	A aa2 = 2;//隐式类型转换，整型转换成自定义类型
	//构造一个A的临时对象，临时对象再拷贝构造aa2 --- > 优化后就直接构造


	//类型转换会产生临时变量
	int i = 10;
	double b = i;
	return 0;
}

在这里插入图片描述
构造一个A的临时对象，临时对象再拷贝构造aa2 — > 优化后就直接构造
在这里插入图片描述
如果不想有这种隐式类型转换，可以使用我们的关键字来说明explicit

class A
{
public:
	explicit A(int a)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& a)
	{
		cout << "A(const int& a)" << endl;
	}

private:
	int _a;
};

int main()
{
	A aa1(1);
	A aa2 = 2;//隐式类型转换，整型转换成自定义类型
	//构造一个A的临时对象，临时对象再拷贝构造aa2 --- > 优化后就直接构造


	//类型转换会产生临时变量
	int i = 10;
	double b = i;
	return 0;
}

在这里插入图片描述

2. static成员

static成员变量
静态成员变量属于类，是共享给每一个类的，不属于谁，存储在静态区，所以他的定义位置要放在全局，类外面定义

class A
{
public:
	//对象成员定义才会使用，因为static是属于每个对象共享的，所以要去类外定义
	A() { ++_scount; }
	A(const A& t) { ++_scount; }
	~A() { --_scount; }
	int GetACount() 
	{ 
		return _scount; 
	}
private:
	//成员变量 -- 属于每个单类的对象，存储在对象里面
	int _a1 = 1;
	int _a2 = 2;

	//静态成员变量 -- 属于类，属于类的每个对象共享，存储在静态区
	static int _scount;
};

//全局位置，类外面定义
int A::_scount = 0;
int main()
{
	A aa1;
	A aa2 = aa1;

	cout << aa1.GetACount() << endl;

	return 0;
}

这里我们看到输出结果为2，是因为在aa2 = aa1的时候进行了优化，直接构造函数，所以输出结果为二
在这里插入图片描述
在这里插入图片描述
当我们使用类进行调用非静态成员函数时，就会报错
static成员函数

class A
{
public:
	//对象成员定义才会使用，因为static是属于每个对象共享的，所以要去类外定义
	A() { ++_scount; }
	A(const A& t) { ++_scount; }
	~A() { --_scount; }
	/*int GetACount() 
	{ 
		return _scount; 
	}*/

	static int GetACount()
	{
		return _scount;
	}
private:
	//成员变量 -- 属于每个单类的对象，存储在对象里面
	int _a1 = 1;
	int _a2 = 2;

	//静态成员变量 -- 属于类，属于类的每个对象共享，存储在静态区
	static int _scount;
};

//全局位置，类外面定义
int A::_scount = 0;
int main()
{
	A aa1;
	A aa2 = aa1;

	cout << aa1.GetACount() << endl;
	cout << A::GetACount() << endl;

	return 0;
}

在这里插入图片描述
可以用类对象调用，也可以直接用类名来调用
静态类里只可以调用静态的变量或函数（这时因为静态类没有this指针）在这里插入图片描述
非静态类是可以调用静态对象的
在这里插入图片描述

3.友元

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

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

流插入符重载

//头文件声明
#include <iostream>
using namespace std;

class Date
{

	//友缘函数
	friend ostream& operator<<(ostream& out, const Date& d);
public:

	//const修饰this指针
	 int GetYear()const
	{
		return _year;
	}

	int GetMonth()const
	{
		return _month;
	}

	int GetDay()const
	{
		return _day;
	}

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

ostream& operator<<(ostream& out, const Date& d);

//源文件定义
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d.GetMonth() << "月" << d._day << "日" << endl;
	return out;
}

int main()
{
	Date d1(2023, 4, 26);
	Date d2(2023, 6, 21);

	cout << d1;
	cout << d1 << d2;
}

在这里插入图片描述
流提取运算符重载

//头文件声明
#include <iostream>
using namespace std;

class Date
{

	//友缘函数
	friend ostream& operator<<(ostream& out, const Date& d);
public:

	friend istream& operator>>(istream& in, Date& d);
	//const修饰this指针
	 int GetYear()const
	{
		return _year;
	}

	int GetMonth()const
	{
		return _month;
	}

	int GetDay()const
	{
		return _day;
	}

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

ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in, Date& d);

//源文件定义
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d.GetMonth() << "月" << d._day << "日" << endl;
	return out;
}

istream& operator>>(istream& in,Date& d)
{
	 
	//in >> d._year >> d._month >> d._day;
	//以上输入不会判断有效日期，接下来我们来
	int year, month, day;
	year = month = day = 0;
	in >> year >> month >> day;
	if (month > 0 && month < 13 && day > 0 && day <= d.GetMonthDay(year,month))
	{
		d._year = year;
		d._month = month;
		d._day = day;
	}
	else
	{
		cout << "非法日期" << endl;
		assert(false);
	}
	return in;
}

int main()
{
	Date d1(2023, 4, 26);
	Date d2(2023, 6, 21);

	cout << d1;
	cin >> d1;
	cout << d1;
}

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

3.2 友元类
  • 友元类的所有函数都可以是另一个类的友元函数，不管公有还是私有都是可以访问的。
  • 友元关系的单向的，不具有交换性。
  • 友元关系不具有传递性，比如 c是b的友元，b是a的友元，但是c和a没有一点关系，两个不挂钩。
  • 友元不具有继承性，后序讲解
#include <iostream>
using namespace std;

class Time
{
    friend class Date;   // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类

public:
    Time(int hour = 0, int minute = 0, int second = 0)
        : _hour(hour)
        , _minute(minute)
        , _second(second)
    {}
private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
        : _year(year)
        , _month(month)
        , _day(day)
    {}

    void dd()
    {

    }

    void SetTimeOfDate(int hour, int minute, int second)
    {
        // 直接访问时间类私有的成员变量
        _t._hour = hour;
        _t._minute = minute;
        _t._second = second;
    }

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

在这里插入图片描述
友元类是单向的
在这里插入图片描述

4. 内部类

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

  • 内部类就是外部类的友元类
  • 内部类可以定义在外部类的public、private、protected都是可以的。
  • 内部类可以直接访问外部类中的static成员，不需要加外部类的对象或者类名
  • sizeof(外部类) = 外部类大小，和内部类没有任何关系
class A
{
public:
	class B
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;
			cout << a.h << endl;
		}
	};

private:
	static int k;
	int h;
};

int A::k = 1;
int main()
{
	A a;
	A::B b;
	b.foo(a);
	cout <<sizeof(a) << endl;
	return 0;
}

在这里插入图片描述

5. 匿名对象

匿名对象特点：

  • 不加const修饰的生命周期只在当行
  • 加了const修饰的在当前局部域
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl << endl << endl;
	}

	~A()
	{
		cout << "~A()" << endl << endl << endl;
	}

private :
	int _a;
};

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


	~Solution()
	{
		cout << "~Solution()" << endl;
	}

	int Sum_Solution(int n)
	{
		return n;
	}
};

int main()
{
	cout << "有名对象生命开始" << endl;
	A a(1);//有名对象 -- 生命周期在当前函数局部域

	cout << "匿名对象生命开始" << endl;
	A(1);//匿名对象 -- 生命周期在当前行
	cout << "匿名对象生命结束" << endl << endl << endl;
	Solution s1;
	s1.Sum_Solution(1);

	cout << endl << "匿名类" << endl;

	//匿名对象调用函数
	Solution().Sum_Solution(2);
	return 0;
}

在这里插入图片描述
在这里插入图片描述

6. 拷贝对象时的一些编译器优化

情况一：

class A
{
public:
	A(int a = 0)
	:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& aa)
	:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

void f1(A aa)
{}
int main()
{
	cout << "f1函数" << endl;
	A aa;
	f1(aa);

	cout << "主函数结束" << endl;
	return 0;
}

在这里插入图片描述
改进代码

class A
{
public:
	A(int a = 0)
	:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& aa)
	:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

void f1(A aa)
{}
//改进后
void f11(const A& aa)
{}

int main()
{
	A aa;
	f11(aa);
	cout << "主函数结束" << endl;
	return 0;
}

在这里插入图片描述
这里我们看到加了引用以后对比不加的情况少了一个拷贝狗造

情况二：

class A
{
public:
	A(int a = 0)
	:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& aa)
	:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

A f2()
{
	A aa;
	cout << "f2函数构造成功" << endl;
	return aa;//返回值时，会进行拷贝工作，但是他的生命周期只在本函数，出了函数自动销毁
}
int main()
{
	f2();
	cout << "主函数结束" << endl;
	return 0;
}

在这里插入图片描述
改进代码


//改进前
A f2()
{
	A aa;
	cout << "f2函数构造成功" << endl;
	return aa;//返回值时，会进行拷贝工作，但是他的生命周期只在本函数，出了函数自动销毁
}

//改进后
A& f22()
{
	static A aa;
	cout << "f22函数构造成功" << endl;
	return aa;
}

在这里插入图片描述
用引用返回也是可以省略一次拷贝构造的

拷贝对象时的优化

A Func5()
{
	A aa;
	return aa;
}

int main()
{
	A ra1 = Func5(); // 拷贝构造 + 拷贝构造 -> 优化为一次拷贝构造
}

拷贝构造 + 拷贝构造 -> 优化为一次拷贝构造
在这里插入图片描述

int main()
{
	//A ra1 = Func5(); // 拷贝构造 + 拷贝构造 -> 优化为一次拷贝构造

	A ra2;
	ra2 = Func5();
	return 0;
}

在这里插入图片描述
构造 + 拷贝构造 -> 优化为一次构造

void Func1(A aa)
{}

	int main()
	{
		//构造 + 拷贝构造 ->  优化为一次构造
		A aa1;
		Func1(aa1);//这样操作是不会有优化的

		cout << "**********************" << endl;
		Func1(A(1));//构造 + 拷贝构造 ->  优化为一次构造
		Func1(1);//构造 + 拷贝构造 ->  优化为一次构造
		A aa2 = 1;//构造 + 拷贝构造 ->  优化为一次构造
		cout << "**********************" << endl;
	return 0;
	}

在这里插入图片描述

Fre丸子_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
类与对象（上）
th15t13的博客
02-04 144
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录类的引入类的访问限定符类的作用域类的实例化如何计算类对象的大小结构体内存对齐规则this指针this指针的特性 类的引入 C语言中，结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。结构体的定义，在C++中更喜欢用class来代替。 class className { // 类体：由成员函数和成员变量组成 }; // 一定要注意后面的分号 类的两种定义方式： 1、声明和定义全部放在类体中，需要
类与对象（一）
xxtzzxx的博客
03-04 378
一、什么是面向过程、面向对象？ 1、面向过程 C语言是面向过程的典型代表，其关注的是解决问题的过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 2、面向对象 C++是基于面向对象的，其关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 3、形象说明 面向过程 -- 吃狗屎 面向对象 -- 狗吃屎 （虽然比较恶心，但是话糙理不糙，希望你不是在边吃边看） 二、类 1、类的引入 事实上，C++中的类和C语言中的结构体的用法上有诸多的共通之处，C++兼容C中结构体的用法，同时也
Java类和对象 详解（一）
热门推荐
wei_zhi的博客
10-06 18万+
一、面向对象简述面向对象是一种现在最为流行的程序设计方法，几乎现在的所有应用都以面向对象为主了，最早的面向对象的概念实际上是由IBM提出的，在70年代的Smaltalk语言之中进行了应用，后来根据面向对象的设计思路，才形成C++，而由C++产生了Java这门面向对象的编程语言。但是在面向对象设计之前，广泛采用的是面向过程，面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主，实
Java - 类与对象
weixin_44949092的博客
04-03 6892
概念 类是对现实生活中一类具有共同属性和行为的事物的抽象。 类的特点 类是对象的数据类型。 类是具有相同属性和行为的一组对象的集合。 对象的概念 既表示客观世界问题空间中的某个具体的事物，又表示软件系统解空间中的基本元素。 对象的属性：对象所具有的各种特征，每个对象的每个特征都拥有特定的值 对象的行为：对象能够执行的操作     类的定义 类是Java程序的基本组成单位 类的组成：属性和行为 属性：在类中通过成员变量来体现（类中方法外的变量） 行为：在类中通过成员方法来体现（和前面的方法相比去掉了stati
java类与对象的关系_类与对象的关系是什么
weixin_35823536的博客
02-20 7163
类与对象的关系是：类和对象之间是抽象与具体的关系。类是一个模板，是对一类事物的抽象描述；对象用于表示现实中该事物的个体。类是在对象之上的抽象，对象则是类的具体化，是类的实例。类与对象有什么关系？类和对象之间是抽象与具体的关系。类是一个模板，是对一类事物的抽象描述，而对象用于表示现实中该事物的个体。类是在对象之上的抽象，对象则是类的具体化，是类的实例。类必须通过对象才可以使用，而对象中的属性和行为必...
类与对象练习.pdf
08-12
面向对象编程（OOP）是一种编程思想，它将复杂的信息对象化，将现实的关系抽象化装化成类，通过封装、继承、多态等方式进行处理。在OOP中，类和对象是两个基本概念。 类（Class）是一种引用数据类型，是对一类事物...
java类与对象
12-21
java类与对象 类与对象的概念类的定义格式对象的创建和使用对象的创建对象访问类的变量与方法成员变量默认值成员变量的封装步骤# 封装中this关键字的使用成员方法的重载overload重载的意义重载的格式构造方法构造...
类与对象的PPT
02-15
类与对象的PPT
第十章 类与对象
01-07
第十章 类与对象 C++重难点知识
类与对象实验报告
06-13
一、实验目的 1．通过对所选题目相关需求的分析，掌握需求分析的方法和过程； 2．掌握需求分析相关文档的组织规范； 3. 完成一个小型软件系统的需求分析。
C++ 类与对象习题
10-14
C++ 类与对象习题，都是入门知识，给初学者参考^-^
类与对象的关系
01-13
讲述类的声明和类体及其构成，构造方法和对象的创建
C#实验报告类与对象实验项目
07-07
C#实验报告类与对象
类与对象的应用
03-01
在本篇讨论中，我们将深入理解“类与对象的应用”，探讨如何定义类、控制类成员的访问权限以及如何利用构造函数和析构函数来管理对象的生命周期。 1. **类的基本概念** 类是面向对象编程的核心，它是描述一类具有...
类与对象.ppt
01-12
类与对象.ppt 讲的很具体。主要涉及基础概念，构造函数，析构函数等
学习Java，你需要知道这些——类与对象
01-20
文章目录类声明与对象创建...类是对一类对象的描述 对象是嘞的具体实例 类声明 方括号中的内容为可选项 [public] [abstract| final] class类名称 [extends父类名称][implements接口名称列表] { 数据成员声明及初始化;
类与对象的应用实例.rar_类与类
最新发布
09-23
例如，可以创建多个位置类对象来表示地图上的多个点，然后用矩形类对象表示区域，方便进行碰撞检测、范围查询等操作。 总结，本实例通过位置类和矩形类展示了面向对象编程的基本概念和应用。通过类的定义、对象的...
VC类与对象详解
02-04
由浅入深讲解VC中的类与对象的概念，使你对类和对象有一个清晰的认识。
类与面向对象知识点归纳整理
12-08
利用结构图对类与对象进行归纳整理，对每个知识点都进行了归纳整理，便于读者查询

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值