C++课程笔记 类和对象

最新推荐文章于 2024-09-16 21:30:36 发布
最新推荐文章于 2024-09-16 21:30:36 发布
阅读量1k 收藏 15
点赞数 25
文章标签： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yugongbaocc/article/details/142031211
版权

类概念

结构体：只要属性

类：有属性也有方法

c++可以省略struct  c不行

#include<iostream>
using namespace std;

typedef struct queue1
{
	int a;
	queue1 q() {
		queue1 q(2);
		return q;
	};
	queue1()
	{

	}
	 queue1(int qa)
	{
		a = qa;
	}
}q1;
int main()
{
	queue1 Q1;
	queue1 Qt=Q1.q();
	cout << Qt.q().a<<endl;
	q1 Q2(2);
	cout << Q1.a<<endl;
	cout << Q2.a;
}

struct内部成员默认公有，class默认私有。

public private不分上下

声明定义分离原因：

方便代码阅读

Q1.h:

#include<iostream>
#include<stdbool.h>
using namespace std;
class Cycle
{
public :
	void Init(int n = 4);
	int getr();
private:
	int r;
};

class Point
{
public:
	void Init(int a = 4,int b=4);
	int geta();
	int getb();
private:
	int a;
	int b;
};
void  ifin(Cycle& c, Point& p);

源.cpp:

#define _CRT_SECURE_NO_WARNINGS 1
#include"Q1.h"
void Cycle::Init(int n) {
	r = n;
}
int Cycle::getr() {
	return r;
}
void Point::Init(int m, int n)
{
	a = m;
	b = n;
}
int Point::geta() {
	return a;
}
int Point::getb() {
	return b;
}
void  ifin(Cycle& c,Point& p)
{
	int d1 = p.geta() * p.geta() + p.getb() * p.getb();
	int d2 = c.getr() * c.getr();
	if (d1 > d2)
	{
		cout << "不在" << endl;
	}
	if (d1 <= d2)
	{
		cout << "在" << endl;
	}
	return;
}

test.cpp

#include"Q1.h"

int main()
{
	
	Cycle c1;
	Point p1;
	ifin(c1, p1);
}

类和对象存储：

成员方法存储在公共区方法

成员变量按结构体空间计算

只有成员函数的类大小都是1

构造函数

构造函数完成初始化

class Date {
public:
	Date(int year, int month)
	{
		_year = year;
		_month = month;
		
	}
	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	/
	Date d1(2019, 4);
	d1.print();
}

class Date {
public:
	Date(int year=2020, int month=2,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date()
	{
		_year = 2019;
		_month = 2;
		_day = 1;
	}
	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	
	Date d1(2021);
	d1.print();
}
class Date {
public:
	Date(int year=2020, int month=2,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date()
	{
	/*	_year = 2019;
		_month = 2;
		_day = 1;*/
	}
	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	
	Date d1;
	d1.print();
}

全缺省构造可代替无参构造

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_top = 0;
		_capacity = 4;
	}
	
	void Push(int t)
	{
		_a[_top++] = t;
	}
	void Print()
	{
		for (int i=0;i<_top;i++)
		{
			cout << _a[i] << endl;
		}
	}
private:
	int* _a;
	int  _top;
	int _capacity;
};
int main()
{
	Stack s;
	s.Push(1);
	s.Push(2);
	s.Print();
}

class A {
public:
	A()
	{
		_a = 1;
		cout << "A()构造函数" << endl;
	}
private:
	int _a;
};
class Date {
public:
	/*Date(int year=2020, int month=2,int day=3)
	{
		_year = year;
		_month = month;
		_day = day;
	}*/
	//Date()
	//{
	///*	_year = 2019;
	//	_month = 2;
	//	_day = 1;*/
	//}
	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	A _A;
};
int main()
{
	
	Date d1;
	return 0;
}

默认构造函数内置类型不处理，自定义类型使用自定义类型默认构造函数。

用栈实现队列中，此类就不用写MyQueue构造函数，可以用MyQueue默认生成的，调用Stack默认构造函数。

释放时也会调用Stack默认析构函数，内置类型同样不会处理，自定义类型调用默认析构函数。

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		cout << "Stack 构造" << endl;
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_top = 0;
		_capacity = 4;
	}
	~Stack()
	{
		cout << "Stack 析构" << endl;
		free(_a);
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
	void Push(int t)
	{
		_a[_top++] = t;
	}
	void Print()
	{
		for (int i=0;i<_top;i++)
		{
			cout << _a[i] << endl;
		}
	}
private:
	int* _a;
	int  _top;
	int _capacity;
	A _A;
};
class MyQueue {

private:
	Stack s1;
};
int main()
{
	
	MyQueue m1;
	return 0;
}

 

自定义类型构造被内置类型扰乱了 

可以用一下c++11特性解决

class Date {
public:
	/*Date(int year=2020, int month=2,int day=3)
	{
		_year = year;
		_month = month;
		_day = day;
	}*/
	//Date()
	//{
	///*	_year = 2019;
	//	_month = 2;
	//	_day = 1;*/
	//}
	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
	int _year=2019;
	int _month=3;
	int _day=3;
	A _A;
};

不传参数就能调用的构造函数是默认构造

析构函数

malloc手动free后销毁

~Stack()
	{
		free(_a);
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}

return时调用析构函数

拷贝构造

class Date {
public:
	Date(int year=2019, int month=2,int day=3)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(Date& d)
	{
		cout << "拷贝构造" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
	int _year=2019;
	int _month=3;
	int _day=3;
	A _A;
};
void Func1(Date d)
{
	cout << "Func1" << endl;
}
void Func2(Date& d) {
	cout << "Func2" << endl;

}
int main()
{
	
	Date d1;
	
	Func1(d1);
	Func2(d1);
	return 0;
}

只要Func1调用了拷贝构造 

拷贝构造前加const 为了避免错误更改原先对象

 

 

class Stack
{
public:
	Stack(int top,int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		cout << "Stack 构造" << endl;
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		cout << "Stack 析构" << endl;
		free(_a);
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
	void Push(int t)
	{
		_a[_top++] = t;
	}
	void Print()
	{
		for (int i=0;i<_top;i++)
		{
			cout << _a[i] << endl;
		}
	}
private:
	int* _a;
	int  _top;
	int _capacity;
	A _A;
};
int main()
{

	
	Stack s(4,4);
	Stack s2(s);

	return 0;
}

 默认拷贝构造是浅拷贝，函数释放后会free两次，会报错

自定义深拷贝：

class Stack
{
public:
	Stack(int top,int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		cout << "Stack 构造" << endl;
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	Stack(const Stack& s)
	{
		_a = (int*)malloc(sizeof(int) * s._capacity);
		{
			if (_a == nullptr)
			{
				perror("malloc fail");
				exit(-1);
			}
		}
		memcpy(_a, s._a, sizeof(int) * s._top);
		_top = s._top;
		_capacity = s._capacity;
	}
	~Stack()
	{
		cout << "Stack 析构" << endl;
		free(_a);
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
	void Push(int t)
	{
		_a[_top++] = t;
	}
	void Print()
	{
		for (int i=0;i<_top;i++)
		{
			cout << _a[i] << endl;
		}
	}
private:
	int* _a;
	int  _top;
	int  _capacity;
	//A _A;
};
int main()
{
	
	
	Stack s(0,4);
	s.Push(1);
	s.Push(2);
	s.Print();
	Stack s2(s);
	return 0;
}

 不用写拷贝构造：

运算符重载

class Date {
public:
	Date(int year=2019, int month=2,int day=3)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(Date& d)
	{
		cout << "拷贝构造" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	

	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
	bool operator ==(const Date& d)
	{
		return _year == d._year && _month == d._month && _day == d._day;

	}
private:
	int _year=2019;
	int _month=3;
	int _day=3;
	A _A;
};
int main()
{
	
	Date d1(2019,3,2);
	Date d2(2020, 4, 3);
	cout << (d1 == d2) << endl;
    //加括号避免运算符优先级问题
	return 0;
}

 

在 C++ 中，运算符重载函数 bool operator==(const Date& d) 只需要一个参数的原因是，它实际上是在定义一个成员函数。成员函数隐含地有一个指向当前对象（即 this 指针）的参数，因此只需要提供与当前对象进行比较的另一个 Date 对象作为参数。

具体解释：

  1. 隐含的 this 指针: 当你在类内部定义一个成员函数时，这个函数可以访问类的成员变量和成员函数。每个成员函数都有一个隐含的 this 指针，它指向调用该函数的对象。operator== 作为成员函数时，隐含的 this 指针会指向调用 == 运算符的那个对象。

    例如，假设有两个 Date 对象 d1 和 d2，当你写 d1 == d2 时，编译器实际上会将其转换为 d1.operator==(d2)。此时，this 指针指向 d1，而 d2 作为参数传递给 operator== 函数。

  2. 参数个数:

    • 成员函数重载: 对于成员函数形式的运算符重载，== 只需要一个参数，因为 this 指针隐式地传递了调用该运算符的对象。

bool operator ==(const Date& d)
	{
		return _year == d._year && _month == d._month && _day == d._day;

	}
	bool operator>(const Date& d)
	{
		if (_year > d._year)
		{
			return true;
		}
		else if (_year == d._year && _month > d._month)
		{
			return true;
		}
		else if (_year == d._year && _month == d._month && _day > d._day)
		{
			return true;
		}
		return false;
	}
	bool operator >=(const Date& d)
	{

计算日期程序： 

class Date {
public:
	Date(int year=2019, int month=2,int day=3)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		cout << "拷贝构造" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//Date()
	//{
	///*	_year = 2019;
	//	_month = 2;
	//	_day = 1;*/
	//}
	int GetMonthDay(int year, int month)
	{
		static int monthday[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		if (month == 2 && (year % 4 == 0 && year % 100 != 0 )|| year % 400 == 0)
		{
			return 29;
		}
		return monthday[month];
	}
	Date operator+=(int day)
	{
		_day = day + _day;
		int monthday = GetMonthDay(_year, _month);
		while (_day > monthday)
		{
			++_month;
			if (_month == 13)
			{
				_year++;
				_month = 1;
			}
			_day = _day - monthday;
			monthday = GetMonthDay(_year, _month);
		}
		return *this;
	}
	Date& operator+(int day)
	{
		Date ret(*this);
		ret += (day);
		return ret;
	}
	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
	bool operator ==(const Date& d)
	{
		return _year == d._year && _month == d._month && _day == d._day;

	}
	bool operator>(const Date& d)
	{
		if (_year > d._year)
		{
			return true;
		}
		else if (_year == d._year && _month > d._month)
		{
			return true;
		}
		else if (_year == d._year && _month == d._month && _day > d._day)
		{
			return true;
		}
		return false;
	}
	bool operator >=(const Date& d)
	{
		return *this == d || *this > d;
	}
private:
	int _year=2019;
	int _month=3;
	int _day=3;
	A _A;
};
int main()
{
	
	Date d1(2024,9,10);
	Date d2(2019, 3, 2);
	cout << (d1 == d2) << endl;
	cout << (d1 > d2) << endl;
	cout << (d1 >= d2) << endl;
	d1 += 100000;
	Date d3(d1+10);
	
	return 0;
}

 

Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
        return *this;
//return d会出现权限放大
	}
int main()
{
	
	Date d1(2024,9,10);
	Date d2(2019, 3, 2);

	d1 = d2;
	return 0;
}

 

不显示写赋值重载，默认生成的，对自定义类型会浅拷贝

显示写重载，先释放，再开辟空间。

Stack& operator=(const Stack& s)
	{
		if(this!=&s)
{
        free(_a);
		_a = (int*)malloc(sizeof(int) * s._capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memcpy(_a, s._a, sizeof(int)*s._top);
		_top = s._top;
		_capacity = s._capacity;
		return *this;
}
	}

运算符重载目的是让自定义类型对象可以用运算符。

this指针默认抢了第一个位置

在.h中定义的Print在两个cpp文件都有定义，链接符号表时出现问题

改成静态可以解决问题 不进符号表

声明定义分离也可以解决问题

.h没有定义，不会进符合表

内敛函数在调用的地方直接展开，也可以解决问题。

友元函数:

友元函数没有this指针。 在类中任意位置可以进行友元声明

可以不用去掉private 

权限放大只出现在指针和引用上。 

this指针默认是不能修改的。 

   

初始化列表

 

 

_m不显示写构造，会调用默认构造

类C没有默认构造:

类C有默认构造:

i给rd引用 i给rd的是临时变量，临时变量具有常性。 

加入explicit就不允许隐式类型转换发生了。 

int N = 0;
class A {
public:
	A(int a)
		:_a(a)
	{
		N++;
		cout << "A()构造函数" << endl;
	}
	A(const A& a)
		:_a(a._a)
	{
		N++;
		cout << "A()拷贝构造函数" << endl;

	}
private:
	int _a;
};
void Func(A a)
{

}
int main()
{
	A a1(1);
	A a2 = 2;
	A a3 = a1;
	Func(a3);
	cout << N<<endl;
}

A a3=a1 构造+拷贝构造被优化成了拷贝构造 

 

A::N，指定类域会到命名空间中找， 不指定会先到局部再到全局中找，找不到会报错。

class A {
public:
	A(int a=1)
		:_a(a)
	{
		N++;
		cout << "A()构造函数" << endl;
	}
	A(const A& a)
		:_a(a._a)
	{
		N++;
		cout << "A()拷贝构造函数" << endl;

	}
	 int GetN()
	{
		return N;
	}
private:
	int _a=1;
	static int N ;
};
int A::N = 0;
int main()
{
	A a1;
	A a2 = 2;
	A a3 = a1;
	//Func(a3);
	cout <<a3.GetN()<<endl;
	cout << a2.GetN() << endl;
}

 

应该n数组构造n个对象 

友元类:

class Time {
	friend  class Date;
public:
	Time(int hour=1, int minute=1, int second=1)
		:_hour(hour)
		, _minute(minute)
		, _second(second)
	{

	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date {
public:
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

	  Date(int year=2019, int month=1,int day=3)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		cout << "拷贝构造" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void SetTime(int hour, int minute, int second)
	{
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
	
private:
	int _year=2019;
	int _month=3;
	int _day=3;
	//A _A;
	Time _t;
};

 内部类:

 

class A {
public:
	A(int a=1)
		:_a(a)
	{
		N++;
		cout << "A()构造函数" << endl;
	}
	A(const A& a)
		:_a(a._a)
	{
		N++;
		cout << "A()拷贝构造函数" << endl;

	}
	class B {
	public:
		void foo()
		{}
	};
	static int GetN()
	{
		return N;
	}
private:
	int _a=1;
	static int N ;
};
int main(){
A::B ab1;
	ab1.foo();
}

匿名对象：

 

创建完直接销毁

 

 

 

 

引用的话需要加const 因为传的是临时变量 具有常性 

 

 

 

南种北李
关注
达内C++课程笔记
07-20
【C++课程笔记详解】 达内的C++课程是专为深入学习编程技术的学员设计的，特别是对于希望在计算机科学领域提升技能或者从事软件开发工作的人来说，这是一个宝贵的资源。本笔记涵盖的内容广泛，旨在帮助学生全面理解...
某课网C++笔记pdf
10-23
根据给定的信息，我们可以从多个角度来探讨C++的相关知识点，包括但不限于集成开发环境的配置、数据类型初始化、命名空间的使用、类和对象的概念、引用类型的理解、指针的操作、函数重载以及内存管理等方面。...
C++深度解析教程笔记7-类和对象
qq_35429166的博客
05-02 2112
int weight;int salary;int weight;Boy b;g.print();b.age = 19;b.print();return 0;
笔记4 · C++类和对象的创建与使用
浓烟下的诗歌电台
07-15 401
类和对象的创建与使用方面的细节
【面向对象编程 C++】笔记（完结）
karshey的博客
04-02 888
前言 是为复习做的笔记。 内容来自课本和老师的课件。 不全面。 第十章 类和对象 面向对象：注重过程，把事件分成小模块。 类和对象的定义与访问 注意：类定义结束处有分号。 类是一种类型，该类型的变量成为对象。 类成员的访问特性： 成员函数的定义 类内声明： 类外定义： 返回值类型 类名::函数名 （函数参数） 对象的存储空间和定义的说明 1、定义对象后，对象数据成员占用不同的存储空间，但所有对象的同一成员函数，共享同一代码空间。 2、自身对象不可以作为自身类的数据成员。 如图，非法： 3、类的
C++学习笔记（面向对象篇）
m0_67682956的博客
09-08 744
C++面向对象程序设计学习笔记
C++学习笔记“类和对象”：继承；
qq_50259950的博客
06-05 679
C++学习笔记“类和对象”：继承；继承的基本语法；继承方式；继承中的对象模型；继承中构造和析构顺序；继承同名成员处理方式；继承同名静态成员处理方式；多继承语法；菱形继承
《黑马程序员C++》课程笔记总结
热门推荐
半生瓜のblog
08-14 16万+
我的小站——半生瓜のblog 黑马程序员C++视频——黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难 笔记列表&对应视频 基础部分(1-83)——如果你准备学习C++,并且有C语言的基础，我希望你能简单的过一遍知识点。 核心部分(84-146)——C++核心编程部分-内存分区模型-引用-函数提高-类与对象-文件操作 案例1(147-166)——职工管理系统——C++实现职工管理系统 进阶部分(167-263)——C++提高编程部分-泛型编程-STL 案例2(264-281)—.
C++第九次课笔记——类和对象（封装）
LqianH6的博客
07-23 267
具有相同性质的，可以抽象称为。
C++入门05 类与对象
weixin_42789937的博客
02-28 1114
听课笔记简单整理，供小伙伴们参考~🥝🥝
C++ 类&对象 学习总结
weixin_45231931的博客
01-16 941
注意：有参构造和拷贝构造可以看成是无参构造的重载，根据传入参数的不同来调用不同的构造函数。
面向对象程序设计 C++总结笔记（1）
shaozheng0503的博客
04-17 1030
理解基本原理+掌握程序设计方法+加强动手实践 1. 理解面向对象程序设计的基本原理，掌握面向对象技术的基本概念和封装性、继承性和多态性，能够具有面向对象程序设计思想。掌握C++语言面向对象的基本特性和C++语言基础知识，能够使用C++语言进行计算机工程领域复杂工程问题的表述，能够进行C++程序阅读和分析。 2. 理解C++语言中的面向对象机制，掌握C++程序设计的一般流程、基本方法和技能。能够综合应用基础知识对复杂的计算机系统工程问题进行用户需求分析，并能够采用面向对象方法进行程序设计。
P127~134C++类和对象继承学习笔记.docx
04-13
C++类和对象继承学习笔记 本文档主要讲解C++类和对象继承的基本语法和应用，通过继承技术减少重复代码，实现代码的重用和简洁。 继承是面向对象三大特性之一，用于描述类与类之间的特殊关系。例如，在实现网页中的...
小甲鱼C++课程笔记
04-22
根据提供的文件内容，我们可以看出这是一份关于C++编程语言的入门课程笔记。笔记内容涵盖了C++语言的基础知识、高级特性以及一些编程技巧。以下是从文件中提取的关键知识点： 1. C++快速入门笔记：这份笔记是为了...
C++教程笔记和资源.zip
08-17
首先，C++是C语言的扩展，它引入了类和对象的概念，使得面向对象编程（OOP）成为可能。在学习C++时，你需要理解基本的数据类型（如int、char、float等）、变量、运算符和控制流（如if语句、for循环、while循环）。...
C++学习笔记----6、内存管理（五）---- 智能指针（3）
weixin_71738303的博客
09-11 1197
与指向特定类型的原始指针可以转化为不同类型的指针一样，shared_ptr保存特定的类型可以转化为一个另一种类型的shared_ptr。转化shared_ptr的函数是const_pointer_cast()，dynamic_pointer_cast(),static_pointer_cast()和reinterpret_pointer_cast()。前面简要提过，当拥有共享属主的智能指针，例如shared_ptr不在活动范围或者被重置时，只有它是最后指向的智能指针时才能释放其指向的资源。
shader 案例学习笔记之将坐标系分成4个象限
localhost
09-13 248
坐标系被分成了4个单元格，每个单元格都有唯一的索引，后续就可以根据索引去渲染。
ROS组合导航笔记1：融合传感器数据
最新发布
qq_44188415的博客
09-16 696
笔记
UEFI学习笔记（五）：EDK II PCD的概念、类型、使用
qq_44189622的博客
09-11 878
如果在BIOS里面有一些模块是binary方式集成进来的而这些binary又需要用到PCD（用于Binary Release），那么这些Binary集成的要用到的PCD就必须要设置为。PCD的值存在memory里面，下次启动时，上次更改的值丢失了，每次启动都是从default值开始。是存在VPD空间的（在FLASH上，只读），一般是出厂配置。如果platform是从源码build出来的，没有binary在里面的时候，PCD用的都是。作用域在一个模块中（模块级的），可以在Binary Level进行修改。
C++学习笔记：类与对象概述
通常，C++课程是高级技术课程，可能是计算机科学专业的必修课。课程内容包括理论和实践两部分，作业布置通常包含选择题、填空题和编程题，通过Moodle等在线平台提交，并有明确的时间限制。 类与对象是C++中面向对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

南种北李

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

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

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

打赏作者

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

抵扣说明：

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

余额充值