【C++】——类和对象

news2024/11/15 2:16:09

目录

    • 面向过程和面向对象的初步认识
    • 类的引入
    • 类的定义
    • 类的访问限定符及封装
    • 类的作用域
    • 类的实例化
    • this指针
    • 类的6个默认成员函数
    • 构造函数
    • 析构函数

面向过程和面向对象的初步认识

C语言是面向过程的，关注的是过程，分析求解问题的步骤，通过函数调用逐步解决问题
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成
C++不是纯面向对象的

在这里插入图片描述

类的引入

C语言中，结构体内只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。（C++兼容C语言，结构体的用法可以继续使用，同时struct也升级成了类）
在这里插入图片描述

struct Stack
{
	//成员函数
	void Init()
	{
		a = nullptr;
		top = capacity = 0;
	}

	//成员变量
	int* a;
	int top;
	int capacity;
};
void StackInit(struct Stack* ps)
{
	//....
}
int main()
{
	struct Stack st1;
	StackInit(&st1);


	Stack st2;
	st2.Init();
	return 0;
}

类的定义

class className
{
	//类体：由成员函数和成员变量组成

};//注意分号

struct和class最主要的区别就是访问限定符

1、类可以做声明和定义分离：
Test.cpp：
在这里插入图片描述
Func.cpp:
在这里插入图片描述
Func.h:
在这里插入图片描述
2、类的两种定义方式：

1、声明和定义全部放在类体中，需要注意：成员函数如果在类中定义，编译器可以能会将其当成内联函数处理。函数不进入符号表。
2、类的声明放在.h文件当中，成员函数定义放在.cpp文件当中，注意：成员函数之前需要加类名。

类的访问限定符及封装

1、访问限定符：public protected private

C++实现封装的方式：用类将对象的属性和方法结合在一起，让对象更加完善，荣光访问权限选择性的将其接口提供给外部的用户使用。

1、public 修饰的成员在类外可以直接被访问
2、protected和private修饰的成员在类外不能直接被访问（此处protected和private是类似的）
3、访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现为止
4、如果后面没有访问限定符，作用域到 } 结束
5、class的默认访问权限是private，struct为public（因为struct要兼容C）

#include <iostream>
using namespace std;
class Stack
{
public :
	//成员函数
	void Init()
	{
		a = nullptr;
		top = capacity = 0;
	}
	void push(int x)
	{
		if (top == capacity)
		{
			int newcapacity = capacity == 0 ? 4 : 2 * capacity;
			a = (int*)realloc(a, sizeof(int) * newcapacity);
			capacity = newcapacity;
		}
		a[top++] = x;
	}
	int Top()
	{
		return a[top - 1];
	}
private:
	//成员变量


	int* a;
	int top;
	int capacity;
};
int main()
{
	Stack st;
	st.Init();
	st.push(1);
	st.push(2);
	st.push(3);
	cout << st.Top() << endl;
	return 0;
}

2、C++中struct和class的区别是什么？

C++需要兼容C语言，所以C++中struct可以当成结构体使用，另外C++中struct还可以用来定义类。和class定义类是一样的。区别是：struct定义类的默认访问权限是public，class定义的类默认访问权限是private。

类的作用域

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

类的实例化

1、 用类类型创建对象的过程，称为类的实例化
2、类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。

在这里插入图片描述

3、 一个类可以实例化出多个对象，类实例化出的对象占用实际的物理空间，类不占用实际的物理空间，存储类成员量。

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;    //是类的声明不是类的定义
	int _day;
};
int main()
{

	Date d;//实例化，开实际的物理空间
	d.Init(2023, 7, 21);
	return 0;
}

类在内存当中不占内存的空间，占文件系统的空间
类不能存储数据，类实例化的对象存储数据

在这里插入图片描述
对象存储方式：
在这里插入图片描述
在这里插入图片描述
计算类的大小：

类中既有成员变量，又有成员函数

class A1 {
public:
	void f1() {}      //4
private:
	int _a;
};

类中仅有成员函数

class A2 {
public:
	void f2() {}        //1
};

类中什么都没有—空类

class A3       //1
{};

分配1字节，不存储数据，只是占位，表示对象存在过

结构体内存对齐规则：

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

this指针

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

此段代码中还隐含了this指针，在编译器中，编译器会默认给代码加上隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

在这里插入图片描述

上述程序代码中，两个成员函数的指针并不是同一个，更准确的来说，是看this指针指向哪个对象，如何指向的是d1对象，那么调用两个成员函数的地址就是相同的。如果同时调用两个对象所指向的成员函数，那么this指针的地址就是不同的。
this指针指向当前调用的对象，是临时变量，函数调用结束后就销毁了

练习题1：

class A
{
public:
void Print()
{
cout << "Print()" << endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->Print();
return 0;
}

运行成功，打印Print( )，该函数存放在公共代码区，不存到成员变量中，所以p指针不解引用，运行成功

练习题2：

class A
{
public:
  void PrintA()
 {
    cout<<_a<<endl;
 }
private:
int _a;
};
int main()
{
  A* p = nullptr;
  p->PrintA();
  return 0;
}

运行崩溃，此处有空指针的解引用，因为函数存放在公共代码区，p指针不解引用是空，同时this指针也是空，导致程序运行崩溃

this指针存放在哪？

this指针是一个形参，一般存在栈栈帧中。VS下面一般会用ecx寄存器直接传递

this指针的特性

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

类的6个默认成员函数

如果一个类当中什么都没有，那么这个类就是空类，但是空类在什么都不写的情况下会自动生成以下6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。
默认构造函数的特点：不传参就可以调用的构造就是默认构造

class classmate
{

};

在这里插入图片描述

构造函数

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

特性：
1、函数名与类名相同
2、无返回值 （也不需要写void）
3、对象实例化时编译器自动调用对应的构造函数
4、构造函数可以重载 （可以写多个构造函数，提供多种初始化方式）

class Date
{
public:
	Date()//无参构造函数
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	Date(int year, int month, int day)//有参构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	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;
};

上述构造函数也可以合并写成参数全缺省形式

class Date
{
public:
	//Date()//无参构造函数
	//{
	//	_year = 1;
	//	_month = 1;
	//	_day = 1;
	//}
	//Date(int year, int month, int day)//有参构造函数
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	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;
	d1.Print();
	Date d2(2023,7,28);
	d2.Print();
	Date d3(2023, 7);
	d3.Print();
	/*d1.Init(2022, 7, 5);
	d1.Print();
	Date d2;
	d2.Init(2022, 7, 6);
	d2.Print();*/
	return 0;
}

C++实现栈：

#include <assert.h>

class Stack
{
public:
	/*Stack()
	{
		a = nullptr;
		top = capacity = 0;
	}*/

	Stack(size_t n = 4)
	{
		if (n == 0)
		{
			a = nullptr;
			top = capacity = 0;
		}
		else
		{
			a = (int*)malloc(sizeof(int) * n);
			if(a == nullptr)
			{
				perror("realloc fail");
				exit(-1);
			}

			top = 0;
			capacity = n;
		}
	}

	// 成员函数
	//void Init()
	//{
	//	a = nullptr;
	//	top = capacity = 0;
	//}

	void Push(int x)
	{
		if (top == capacity)
		{
			size_t newcapacity = capacity == 0 ? 4 : capacity * 2;
			int* tmp = (int*)realloc(a, sizeof(int) * newcapacity);
			if (tmp == nullptr)
			{
				perror("realloc fail");
				exit(-1);//程序以异常的方式退出
			}
			if (tmp == a)
			{
				cout << capacity << "原地扩容" << endl;
			}
			else
			{
				cout << capacity << "异地扩容" << endl;
			}

			a = tmp;
			capacity = newcapacity;
		}

		a[top++] = x;
	}

	int Top()
	{
		return a[top - 1];
	}

	void Pop()
	{
		assert(top > 0);
		--top;
	}

	void Destroy()
	{
		free(a);
		a = nullptr;
		top = capacity = 0;
	}

	bool Empty()
	{
		return top == 0;
	}
private:
	// 成员变量
	int* a;
	int top;
	int capacity;
};

int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
	st1.Push(3);
	st1.Push(4);
	
	while (!st1.Empty())
	{
		cout << st1.Top() << " ";
		st1.Pop();
	}
	cout << endl;

	st1.Destroy();

	//Stack st2(1000);
	Stack st2;
	for (size_t i = 0; i < 1000; i++)
	{
		st2.Push(i);
	}

	while (!st2.Empty())
	{
		cout << st2.Top() << " ";
		st2.Pop();
	}
	cout << endl;

	st2.Destroy();
}

推荐在一个类当中使用全缺省构造函数
构造函数，也是默认成员函数，我们不写，编译器会自动生成
编译生成的构造函数的特点：
1、我们不写才会自动生成，我们写了就不会自动生成了
2、内置类型（基本类型 int double）成员不会处理，（C++11，声明支持给缺省值）
3、对于自定义类型的成员才会处理，会去调用这个成员的默认构造函数
如果类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义编译器将不再生成。
无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个（多个并存会存在调用的二义性）。
注意：无参构造函数，全缺省构造函数，我们没有写编译器默认生成的构造函数，都可以认为时默认构造函数（不传参就可以调用的）。
一般情况下都需要我们自己写构造函数，决定初始化方式

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
int main()
{
	//MyQueue mq;
	Time t;
	return 0;
}

举例：

class A
{
public:
	A(int a)
	{
		cout << "A(int a)" << endl;
	}
private:
	int _a;
};
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;

	A _aa;

};
int main()
{
	Date d1;
	//Date d2(2023, 7, 29);
	return 0;
}

运行报错：
在这里插入图片描述

错误原因：类A中不存在默认构造函数，默认构造函数：无参的构造函数和全缺省的构造函数。

代码更正：将类A中的构造函数写成参数全缺省形式

class A
{
public:
	A(int a=1)
	{
		cout << "A(int a)" << endl;
	}
private:
	int _a;
};
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;

	A _aa;

};
int main()
{
	Date d1;
	//Date d2(2023, 7, 29);
	return 0;
}

析构函数

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

特性：
1、析构函数名是在类名前加上字符“~”
2、无参数无返回值类型
3、一个类只能有一个析构函数，若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
4、对象生命周期结束时，C++编译系统自动调用析构函数
默认的析构函数：
对内置类型成员不做处理
自定义类型的成员会去调用他的析构函数

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
	~Time()
	{
		cout << "~Time()" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
int main()
{
	
	Time t;
	return 0;
}

栈需要显式的写析构函数

class Stack
{
public:
	//构造函数
	Stack(size_t n = 4)//unsigned int
	{
		if (n == 0)
		{
			a = nullptr;
			top = capacity = 0;
		}
		else
		{
			a = (int*)malloc(sizeof(int) * n);
			if (a == nullptr)
			{
				perror("malloc fail");
				exit(-1);//异常
			}
			top = 0;
			capacity = n;
		}
	}
	int Top()
	{
		return a[top - 1];
	}
	void Pop()
	{
		assert(top > 0);
		top--;
	}
	void Push(int x)
	{
		if (top == capacity)
		{
			size_t newcapacity = capacity == 0 ? 4 : capacity * 2;
			int* tmp = (int*)realloc(a, sizeof(int) * newcapacity);
			if (tmp == nullptr)
			{
				perror("realloc fail");
				exit(-1);
			}
			if (tmp == a)
			{
				cout << capacity << "原地" << endl;
			}
			else
			{
				cout << capacity << "异地" << endl;
			}
			a = tmp;
			capacity = newcapacity;
		}
		a[top++] = x;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(a);
		a = nullptr;
		top = 0;
		capacity = 0;

	}
	bool Empty()
	{
		return top == 0;
	}
private:
	int* a;
	int top;
	int capacity;
};
int main()
{
	Stack st1(1000);
	st1.Push(1);
	st1.Push(2);
	while (!st1.Empty())
	{
		cout << st1.Top() << endl;
		st1.Pop();
	}
	return 0;
}

在这里插入图片描述

默认析构函数：
1、内置类型成员不会处理
2、自定义类型成员会调用这个成员的析构函数

C++实现括号匹配

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

class Stack
{
public:
	Stack(size_t n = 4)//构造函数
	{
		cout << "Stack(size_t n = 4)" << endl;

		if (n == 0)
		{
			a = nullptr;
			top = capacity = 0;
		}
		else
		{
			a = (int*)malloc(sizeof(int) * n);
			if (a == nullptr)
			{
				perror("realloc fail");
				exit(-1);
			}

			top = 0;
			capacity = n;
		}
	}

	~Stack()//析构函数
	{
		cout << "~Stack()" << endl;
		free(a);
		a = nullptr;
		top = capacity = 0;
	}

	void Push(int x)
	{
		if (top == capacity)
		{
			size_t newcapacity = capacity == 0 ? 4 : capacity * 2;
			int* tmp = (int*)realloc(a, sizeof(int) * newcapacity);
			if (tmp == nullptr)
			{
				perror("realloc fail");
				exit(-1);
			}
			if (tmp == a)
			{
				cout << capacity << "原地扩容" << endl;
			}
			else
			{
				cout << capacity << "异地扩容" << endl;
			}

			a = tmp;
			capacity = newcapacity;
		}

		a[top++] = x;
	}

	int Top()
	{
		return a[top - 1];
	}

	void Pop()
	{
		assert(top > 0);
		--top;
	}

	void Destroy()
	{
		free(a);
		a = nullptr;
		top = capacity = 0;
	}

	bool Empty()
	{
		return top == 0;
	}
private:
	// 成员变量
	int* a;
	int top;
	int capacity;
};
bool isValid(const char* s) {
	Stack st;
	while (*s)
	{
		if (*s == '[' || *s == '(' || *s == '{')
		{
			st.Push(*s);
			++s;
		}
		else
		{
			// 不匹配
			if (st.Empty())
				return false;

			char top = st.Top();
			st.Pop();

			// 不匹配
			if ((*s == ']' && top != '[')
				|| (*s == ')' && top != '(')
				|| (*s == '}' && top == '{'))
			{
				return false;
			}

			++s;
		}
	}

	return st.Empty();
}

int main()
{
	// 后定义，先析构
	

	Stack st1;
	Stack st2;

	cout << isValid("[[]]()()") << endl;
	cout << isValid("[[]]]") << endl;


	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/811819.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

你还不会反射吧，快来吧！！！

你还不会反射吧，快来吧！！！

首先&#xff1a; 1.加载类&#xff1a; //练习获取字节码对象的3种方式 //Class<Student> studentClass Student.class; //Class<? extends Student> aClass new Student().getClass(); Class<?> clazz Class.forName("TestT.Student"); 2.获…
阅读更多...
[C++] 类与对象（上）

[C++] 类与对象（上）

目录 1、前言 2、类的引入 3、类的定义 3.1 类的两种定义方式 4、类的访问限定符 5、类的作用域 6、类的实例化 7、类对象模型 7.1 内存对齐规则 7.1 类对象的存储方式 8、this指针 8.1 this指针的特性 8.2 this指针是否可以为空 1、前言 C语言是面向过程的&#…
阅读更多...
网络运维基础问题及解答

网络运维基础问题及解答

前言 本篇文章是对于网络运维基础技能的一些常见问题的解答&#xff0c;希望能够为进行期末复习或者对网络运维感兴趣的同学或专业人员提供一定的帮助。 问题及解答 1. 列举 3 种常用字符编码&#xff0c;简述怎样在 str 和 bytes 之间进行编码和解码。 答&#xff1a;常用的…
阅读更多...
Python读取多个栅格文件并提取像元的各波段时间序列数据与变化值

Python读取多个栅格文件并提取像元的各波段时间序列数据与变化值

本文介绍基于Python语言&#xff0c;读取文件夹下大量栅格遥感影像文件&#xff0c;并基于给定的一个像元&#xff0c;提取该像元对应的全部遥感影像文件中&#xff0c;指定多个波段的数值&#xff1b;修改其中不在给定范围内的异常值&#xff0c;并计算像元数值在每一景遥感影…
阅读更多...
【C++】-动态内存管理

【C++】-动态内存管理

作者&#xff1a;小树苗渴望变成参天大树 作者宣言&#xff1a;认真写好每一篇博客 作者gitee:gitee 如 果 你 喜 欢 作 者 的 文 章 &#xff0c;就 给 作 者 点 点 关 注 吧&#xff01; 文章目录 前言一、C内存管理方式1.1 new/delete操作内置类型 总结 前言 今天再讲一个…
阅读更多...
【禁用外键】为什么互联网大厂禁用外键约束？详谈外键的优缺点和使用场景

【禁用外键】为什么互联网大厂禁用外键约束？详谈外键的优缺点和使用场景

导航&#xff1a; 【Java笔记踩坑汇总】Java基础进阶JavaWebSSMSpringBoot瑞吉外卖SpringCloud黑马旅游谷粒商城学成在线MySQL高级篇设计模式常见面试题源码 目录 一、外键介绍 1.1 概述 1.2 练习 1.2.1 数据准备 1.2.2 验证有外键时&#xff0c;删除记录要维护外键 1.2…
阅读更多...
Python批量下载主播照片，实现人脸识别, 进行颜值评分，制作颜值排行榜

Python批量下载主播照片，实现人脸识别, 进行颜值评分，制作颜值排行榜

昨晚一回家&#xff0c;表弟就神神秘秘的跟我说&#xff0c;发现一个高颜值网站&#xff0c;非要拉着我研究一下她们的颜值高低。 我心想&#xff0c;这还得要我一个个慢慢看&#xff0c;太麻烦了~ 于是反手用Python给他写了一个人脸识别代码&#xff0c;把她们的照片全部爬下…
阅读更多...
06-行向量列向量_向量的运算 加法，数乘，减法，转置

06-行向量列向量_向量的运算 加法，数乘，减法，转置

行向量和列向量 行向量是按行把向量排开&#xff08;横着来写&#xff09;&#xff0c; 列向量是按列把向量排开&#xff08;竖着来写&#xff09; 在数学中我们更多的把数据写成列向量&#xff0c;在编程语言中更多的把数据存成行向量! 如果想在编程语言中把行向量转化成列…
阅读更多...
人力资源管理系统servlet jsp人资企业办公java源代码mysql

人力资源管理系统servlet jsp人资企业办公java源代码mysql

本项目为前几天收费帮学妹做的一个项目&#xff0c;Java EE JSP项目&#xff0c;在工作环境中基本使用不到&#xff0c;但是很多学校把这个当作编程入门的项目来做&#xff0c;故分享出本项目供初学者参考。 一、项目描述 人力资源管理系统ervlet jsp 系统有1权限&#xff1a…
阅读更多...
【计算机网络】408统考2014年题36

【计算机网络】408统考2014年题36

题目描述 【2014年题36】主机甲与主机乙之间使用后退N帧(GBN)协议传输数据&#xff0c;甲的发送窗口尺寸为1000&#xff0c;数据帧长为1000字节&#xff0c;信道带宽为100Mbps&#xff0c;乙每收到一个数据帧就立即利用一个短帧&#xff08;忽略其传输延迟&#xff09;进行确认…
阅读更多...
动态sql以及常用的标签

动态sql以及常用的标签

什么是动态sql&#xff1a; 指根据不同的条件生成不同的sql 搭建环境&#xff1a; 建表&#xff1a; create table blog( id varchar(50) not null comment 博客id, title varchar(100) not null comment 博客标题, author varchar(30) not null comment 博客作者, create_ti…
阅读更多...
基于springboot+mybatis+mysql+vue+html民宿管理平台

基于springboot+mybatis+mysql+vue+html民宿管理平台

基于springbootmybatismysqlvuehtml民宿管理平台 一、系统介绍二、功能展示1.首页2.个人中心3.民宿信息浏览(用户)4房间信息浏览&#xff08;用户&#xff09;5.房间预订&#xff08;用户&#xff09;6.房间退订&#xff08;用户&#xff09;7.投诉反馈&#xff08;用户&#x…
阅读更多...
如何配置保存cpolar所建立的隧道参数？

如何配置保存cpolar所建立的隧道参数？

文章目录 可以利用cpolar建立一个能发布到公共互联网的网页&#xff0c;这是基于我们直接对cpolar进行即时设置&#xff0c;获得了能在公共互联网上访问本地数据的二级子域名。但如果电脑关闭重启后&#xff0c;如何让电脑自动启动cpolar&#xff0c;并记住设置好的域名参数文件…
阅读更多...
一文搞懂自动驾驶芯片TDA4 启动流程

一文搞懂自动驾驶芯片TDA4 启动流程

文章目录 TDA4架构简介TDA4启动流程DMSC ROM阶段MCU域R5 ROM阶段SBL阶段 TDA4架构简介 TDA4是德州仪器推出的一款高性能、超异构的多核SoC&#xff0c;拥有ARM Cortex-R5F、ARM Cortex-A72、C66以及C71内核&#xff0c;可以部署AUTOSAR CP系统、HLOS(Linux或QNX)、图像处理以及…
阅读更多...
tinkerCAD案例：23.Tinkercad 中的自定义字体

tinkerCAD案例：23.Tinkercad 中的自定义字体

tinkerCAD案例&#xff1a;23.Tinkercad 中的自定义字体 原文 Tinkercad Projects Tinkercad has a fun shape in the Shape Generators section that allows you to upload your own font in SVG format and use it in your designs. I’ve used it for a variety of desi…
阅读更多...
Python实现GA遗传算法优化循环神经网络分类模型(LSTM分类算法)项目实战

Python实现GA遗传算法优化循环神经网络分类模型(LSTM分类算法)项目实战

说明&#xff1a;这是一个机器学习实战项目&#xff08;附带数据代码文档视频讲解&#xff09;&#xff0c;如需数据代码文档视频讲解可以直接到文章最后获取。 1.项目背景 遗传算法&#xff08;Genetic Algorithm&#xff0c;GA&#xff09;最早是由美国的 John holland于20世…
阅读更多...
(文章复现)梯级水光互补系统最大化可消纳电量期望短期优化调度模型matlab代码

(文章复现)梯级水光互补系统最大化可消纳电量期望短期优化调度模型matlab代码

参考文献&#xff1a; [1]罗彬,陈永灿,刘昭伟等.梯级水光互补系统最大化可消纳电量期望短期优化调度模型[J].电力系统自动化,2023,47(10):66-75. 1.基本原理 1.1 目标函数 考虑光伏出力的不确定性&#xff0c;以梯级水光互补系统的可消纳电量期望最大为目标&#xff0c;函数…
阅读更多...
递归求解汉诺塔问题（超详解）

递归求解汉诺塔问题（超详解）

问题提出 这个问题是关于三根柱子和一些圆盘的游戏。 初始时&#xff0c;所有的圆盘按照从大到小的顺序叠放在一根柱子上&#xff0c;目标是将所有圆盘从起始柱子移动到目标柱子上&#xff0c;在移动过程中&#xff0c;要满足以下规则喵&#xff1a; 每次只能移动一个圆盘。大圆…
阅读更多...
混动才是未来？福特电车亏损数十亿美元，聚焦混动展望未来

混动才是未来？福特电车亏损数十亿美元，聚焦混动展望未来

福特汽车公司决定聚焦混合动力汽车&#xff0c;以弥补电动汽车市场亏损数十亿美元。吉姆法利首席执行官表示&#xff0c;在最新财报发布会上透露&#xff0c;未来将推出更多种类的混合动力车型。 福特最近公布了Q2盈亏情况&#xff0c;显示电动汽车部门的亏损有所增加。不过&am…
阅读更多...
从源码角度配合网络编程函数accept() connect()等实现的客户端服务器通信 分析下 三握手四挥手都做了什么

从源码角度配合网络编程函数accept() connect()等实现的客户端服务器通信 分析下 三握手四挥手都做了什么

首先我们先说下网络编程API&#xff1a; 数据在网络上通信&#xff0c;通信的双方一个是 客户端&#xff0c; 一个是 服务器 更具体来说&#xff0c;不是 客户端和服务器这两个机器在 经由互联网 进行通信&#xff0c; 而是 客户端上的某一进程 与 服务器端的某一进程 进…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023