【C++】——类和对象

目录

    • 面向过程和面向对象的初步认识
    • 类的引入
    • 类的定义
    • 类的访问限定符及封装
    • 类的作用域
    • 类的实例化
    • 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;
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

PHP使用PhpSpreadsheet实现导出Excel时带下拉框列表 (可支持三级联动)

PHP使用PhpSpreadsheet实现导出Excel时带下拉框列表 (可支持三级联动)

因项目需要导出Excel表 需要支持下拉 且 还需要支持三级联动功能 目前应为PHPExcel 不在维护&#xff0c;固采用 PhpSpreadsheet 效果如图&#xff1a; 第一步&#xff1a;首先 使用composer 获取PhpSpreadsheet 我这里PHP 版本 7.4 命令如下&#xff1a; composer r…
阅读更多...
【计算机视觉 | 目标检测 | 图像分割】arxiv 计算机视觉关于目标检测和图像分割的学术速递（7 月 31 日论文合集）

【计算机视觉 | 目标检测 | 图像分割】arxiv 计算机视觉关于目标检测和图像分割的学术速递（7 月 31 日论文合集）

文章目录 一、检测相关(9篇)1.1 Semi-Supervised Object Detection in the Open World1.2 Multi-layer Aggregation as a key to feature-based OOD detection1.3 Non-invasive Diabetes Detection using Gabor Filter: A Comparative Analysis of Different Cameras1.4 Local …
阅读更多...
ABAP 自定义搜索功能 demo1

ABAP 自定义搜索功能 demo1

ABAP 自定义搜索功能 demo1 效果&#xff1a; 双击选中行则为选中对应发票 实现 1定义 定义屏幕筛选参数 SELECTION-SCREEN BEGIN OF SCREEN 9020. SELECT-OPTIONS:s1_belnr FOR rbkp-belnr, s1_gjahr FOR rbkp-gjahr, s1_lifnr FOR rbkp-lifnr, s1_erfna FOR rbkp-erfnam, …
阅读更多...
详解AMQP协议

详解AMQP协议

目录 1.概述 1.1.简介 1.2.抽象模型 2.spring中的amqp 2.1.spring amqp 2.2.spring boot amqp 1.概述 1.1.简介 AMQP&#xff0c;Advanced Message Queuing Protocol&#xff0c;高级消息队列协议。 百度百科上的介绍&#xff1a; 一个提供统一消息服务的应用层标准高…
阅读更多...
插入排序算法

插入排序算法

插入排序 算法说明与代码实现&#xff1a; 以下是使用Go语言实现的插入排序算法示例代码&#xff1a; package mainimport "fmt"func insertionSort(arr []int) {n : len(arr)for i : 1; i < n; i {key : arr[i]j : i - 1for j > 0 && arr[j] > …
阅读更多...
深入理解负载均衡原理及算法

深入理解负载均衡原理及算法

1. 前言 在互联网早期，网络还不是很发达，上网用户少，流量相对较小，系统架构以单体架构为主。但如今在互联网发达的今天，流量请求动辄百亿、甚至上千亿，单台服务器或者实例已完全不能满足需求，这就有了集群。不论是为了实现高可用还是高性能，都需要用到多台机器来扩展服…
阅读更多...
react中hooks分享

react中hooks分享

一. HOOKS是什么 在计算机程序设计中&#xff0c;钩子一词涵盖了一系列技术&#xff0c;这些技术用来通过拦截函数调用、消息或在软件组件之间传递的事件来改变或增加操作系统、应用程序或其他软件组件的行为。处理这些被截获的函数调用、事件或消息的代码称为“hook”。 在r…
阅读更多...
【Python】PySpark 数据计算 ⑤ ( RDD#sortBy方法 - 排序 RDD 中的元素 )

【Python】PySpark 数据计算 ⑤ ( RDD#sortBy方法 - 排序 RDD 中的元素 )

文章目录 一、RDD#sortBy 方法1、RDD#sortBy 语法简介2、RDD#sortBy 传入的函数参数分析 二、代码示例 - RDD#sortBy 示例1、需求分析2、代码示例3、执行结果 一、RDD#sortBy 方法 1、RDD#sortBy 语法简介 RDD#sortBy 方法 用于 按照 指定的 键 对 RDD 中的元素进行排序 , 该方…
阅读更多...
细讲一个 TCP 连接能发多少个 HTTP 请求（一）

细讲一个 TCP 连接能发多少个 HTTP 请求（一）

一道经典的面试题是从 URL 在浏览器被被输入到页面展现的过程中发生了什么&#xff0c;大多数回答都是说请求响应之后 DOM 怎么被构建&#xff0c;被绘制出来。但是你有没有想过&#xff0c;收到的 HTML 如果包含几十个图片标签&#xff0c;这些图片是以什么方式、什么顺序、建…
阅读更多...
Arthas GC日志-JVM（十八）

Arthas GC日志-JVM（十八）

上篇文章说jvm的实际运行情况。 Jvm实际运行情况-JVM&#xff08;十七&#xff09; Arthas介绍 因为arthas完全是java代码写的&#xff0c;我们直接用命令启动&#xff1a; Java -jar arthas-boot.jar 启动成功后&#xff0c;选择我们项目的进程。 进入我们可用dashboard…
阅读更多...
django实现部门表的增删改查界面

django实现部门表的增删改查界面

1、前期准备 部署好mysql数据库&#xff0c;创建好unicom数据库下载好bootstap的插件下载好jquery的插件下载好mysqlclient-1.4.6-cp36-cp36m-win_amd64.whl的安装包&#xff0c;根据python的版本下载 2、创建项目 在pycharm中创建项目 在pycharm的终端创建虚拟环境 py -m v…
阅读更多...
【Docker】Docker安装Elasticsearch服务的正确方式

【Docker】Docker安装Elasticsearch服务的正确方式

文章目录 1. 什么是Elasticsearch2. Docker安装Elasticsearch2.1 确定Elasticsearch的版本2.2. Docker安装Elasticsearch2.3. 给Elasticsearch安装中文分词器IKAnalyzer&#xff08;可选&#xff09; 点击跳转&#xff1a;Docker安装MySQL、Redis、RabbitMQ、Elasticsearch、Na…
阅读更多...
Django使用uwsgi+nginx部署,admin没有样式解决办法

Django使用uwsgi+nginx部署,admin没有样式解决办法

Django使用uwsginginx部署,admin没有样式解决办法 如果使用了虚拟环境则修改nginx.conf文件中的/static/路径为你虚拟环境的路径&#xff0c;没有使用虚拟环境则改为你python安装路径下的static server {listen 8008;server_name location; #改为自己的域名&#xff0c;没域名…
阅读更多...
mybatisplus实现自动填充 时间

mybatisplus实现自动填充 时间

mybatisplus实现自动填充功能——自动填充时间 数据库表中的字段 创建时间 (createTime)更新时间 (updateTime) 每次 增删改查的时候&#xff0c;需要通过对Entity的字段&#xff08;createTime&#xff0c;updateTime&#xff09;进行set设置&#xff0c;但是&#xff0c;每…
阅读更多...
途乐证券|俄罗斯宣布9月削减石油出口量

途乐证券|俄罗斯宣布9月削减石油出口量

当地时间周四&#xff0c;美股兜售潮仍在持续&#xff0c;三大股指连续第二个交易日团体收跌。到收盘&#xff0c;道指跌落0.19%&#xff0c;标普500指数跌落0.25%&#xff0c;纳指跌幅为0.10%。 美国ISM7月非制造业PMI下滑 数据面上&#xff0c;美国供应办理协会ISM周四发布的…
阅读更多...
电力巡检无人机助力迎峰度夏，保障夏季电力供应

电力巡检无人机助力迎峰度夏，保障夏季电力供应

夏季是电力需求量较高的时期&#xff0c;随着高温天气的来临&#xff0c;风扇、空调和冰箱等电器的使用量也大大增加&#xff0c;从而迎来夏季用电高峰期&#xff0c;电网用电负荷不断攀升。为了保障夏季电网供电稳定&#xff0c;供电公司会加强对电力设施设备的巡检&#xff0…
阅读更多...
mmap函数详解

mmap函数详解

1、什么是mmap mmap是一种内存映射文件的方法&#xff0c;即将一个文件或者其它对象映射到进程的地址空间&#xff0c;实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。 实现这样的映射关系后&#xff0c;进程就可以采用指针的方式读写操作这一段内存&#x…
阅读更多...
Android入门教程||Android 架构||Android 应用程序组件

Android入门教程||Android 架构||Android 应用程序组件

Android 架构 Android 操作系统是一个软件组件的栈&#xff0c;在架构图中它大致可以分为五个部分和四个主要层。 Linux内核 在所有层的最底下是 Linux - 包括大约115个补丁的 Linux 3.6。它提供了基本的系统功能&#xff0c;比如进程管理&#xff0c;内存管理&#xff0c;设…
阅读更多...
Android 面试题 应用程序结构 十一

Android 面试题 应用程序结构 十一

&#x1f525; Framework主要包含以下模块 &#x1f525; ActivityManagerService 这是一个Activity的管理者&#xff0c;负责管理所有Activity的生命周期。WindowManagerService 它是手机屏幕的的管理者&#xff0c;管理着屏幕的详细情况&#xff0c;所有对屏幕的操作最终都…
阅读更多...
express学习笔记4 - 热更新以及express-boom

express学习笔记4 - 热更新以及express-boom

我们每次改动代码的时候都要重启项目&#xff0c;现在我们给项目添加一个热更新 npm install --save-dev nodemon # or using yarn: yarn add nodemon -D 在package.json添加一行代码 "dev": "nodemon ./bin/www" 重启项目 然后随便做改动&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023