类和对象(提高)
类和对象(提高)
1、定义一个类 关键字class
6 class Data1
7 {
8 //类中 默认为私有
9 private:
10 int a;//不要给类中成员 初始化
11 protected://保护
12 int b;
13 public://公共
14 int c;
15 //在类的内部 不存在权限之分
16 void showData(void)
17 {
18 cout<<a<<" "<<b<<" "<<c<<endl;
19 }
20 };
2、成员函数在类外实现
class Student
{
private:int age;
public:void setAge(int a);void getAge(void);
};void Student::setAge(int a)
{age=a;
}void Student::getAge()
{cout<<age<<endl;
}
3、类在其他文件实现
头文件定义类, cpp实现类的成员函数
eg:student.h中
#ifndef STUDENT_H
#define STUDENT_Hclass Student
{
private:int age;
public:void setAge(int a);void getAge(void);
};#endif // STUDENT_H
student.cpp中
#include "student.h" //引入头文件
#include<iostream>
using namespace std;void Student::setAge(int a)
{age=a;
}void Student::getAge()
{cout<<age<<endl;
}
main.cpp实现student类
#include <iostream>
#include <cstring>
#include"student.h"
using namespace std;int main(){
Student stu1;
stu1.setAge(18);
stu1.getAge();return 0;
}
构造函数
1、如果用户不提供构造函数 编译器会自动 提供一个无参的空的构造函数。
2、如果用户提供构造函数 编译器会自动 屏蔽默认无参的构造
class Data{
int mA;public:
Data(){mA = 0;cout<<"无参构造函数"<<endl;
}Data(int a)
{mA = a;cout<<"有参构造函数"<<endl;}
};
void test01(){//隐式调用无参构造(推荐)Data ob1;//显示调用无参构造Data ob2=Data();//隐式调用有参构造(推荐)Data ob3(10);//显示调用有参构造Data ob4=Data(20);//如果构造函数只有一个参数 可能发生 构造函数的隐式转换(知道就行)Data ob5 = 30;//Data ob5(30);//匿名对象:当前语句结束 对象就要被释放Data();//调用无参Data(40);//调用有参cout<<ob4.mA<<endl;}
析构函数
当对象生命周期结束的时候 系统自动调用析构函数。
函数名和类名称相同,在函数名前加~,没有返回值类型,没有函数形参。(不能被重载)
先调用析构函数 再释放对象的空间。
class Data1{public:int mA;public://无参构造函数Data1(){mA=0;cout<<"无参构造函数"<<endl;}//有参构造函数Data1(int a){mA=a;cout<<"有参构造函数 mA="<<mA<<endl;}//析构函数~Data1(){cout<<"析构函数 mA="<<mA<<endl;}};
一般情况下,空的析构函数就足够。但是如果一个类有指针成员,这个类必须 写析构函数,释放指针成员所指向空间。
#include <iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;class Data1{
private:char *name;public:Data1(char *str){name=(char *)calloc(1,strlen(str)+1);strcpy(name,str);}//释放指针空间~Data1(){cout<<"析构函数 name="<<name<<endl;if(name!=NULL){free(name);name=NULL;}}};int main(int argc, char *argv[])
{
Data1("张三");return 0;
}
拷贝构造函数
拷贝构造:本质是构造函数
拷贝构造的调用时机:旧对象 初始化 新对象 才会调用拷贝构造。
#include <iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;class Data1{public:int numA;
//拷贝函数
Data1(const Data1 &ob){//ob就是旧对象的别名numA=ob.numA;//一旦实现 了拷贝构造 必须完成赋值动作cout<<"调用拷贝函数"<<endl;
}
Data1(int a){numA=a;
}};int main(int argc, char *argv[])
{
Data1 ob1=Data1(10);
Data1 ob2=ob1;
cout<<"ob2:numA="<<ob2.numA<<endl;return 0;
}
如果用户不提供拷贝构造 编译器会自动提供一个默认的拷贝构造(完成赋值动作–浅拷贝)
拷贝构造 和 无参构造 有参构造的关系:
如果用户定义了 拷贝构造或者有参构造 都会屏蔽无参构造。
如果用户定义了 无参构造或者有参构造 不会屏蔽拷贝构造
拷贝构造函数几种调用方式
1、旧对象给新对象初始化,调用拷贝构造
Data4 ob1(10);
Data4 ob2 = ob1;//调用拷贝构造
2、给对象取别名 不会调用拷贝构造
Data4 ob1(10);
Data4 &ob2 = ob1;//不会调用拷贝构造
3、普通对象作为函数参数 调用喊谁时 会发生拷贝构造
void fun1(Data1 ob){//Data1 ob=obAcout<<ob.numA<<endl;
}int main(int argc, char *argv[])
{Data1 obA(10);fun1(obA);return 0;
}
4、函数返回值普通对象 (Visual Studio会发生拷贝构造)(Qtcreater,linux不会发生)Visual Studio会发生拷贝构造
深拷贝
1、默认的拷贝构造 都是浅拷贝。
2、如果类中没有指针成员, 不用实现拷贝构造和析构函数。
3、如果类中有指针成员, 必须实现析构函数释放指针成员指向的堆区空间,必须实现拷贝构造完成深拷贝动作。
#include <iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;class Data1{public:char *name;//有参构造
Data1(char *n){name=(char *)calloc(1,strlen(n)+1);strcpy(name,n);
}~Data1(){cout<<"析构函数 name="<<name<<endl;
if(name!=NULL){free(name);name=NULL;
}}
//深拷贝
Data1(const Data1 &ob){
name=(char *)calloc(1,strlen(ob.name)+1);
strcpy(name,ob.name);
}};int main(int argc, char *argv[])
{Data1 obA("hello world");
Data1 ob=obA;return 0;
}
初始化列表
成员对象:一个类的对象作为另一个类的成员
如果类中想调用成员对象的有参构造 必须使用初始化列表。
class DataA{
public :int a;
public:DataA(){cout<<"A的无参构造"<<endl;}DataA(int num){a=num;cout<<"A的有参构造"<<endl;}~DataA(){cout<<"A的析构函数"<<endl;}
};class DataB{
public:int b;DataA ob;
public:DataB(){cout<<"B的无参构造"<<endl;}DataB(int num,int numa){b=num;ob.a=numa;cout<<"B的有参构造"<<endl;}~DataB(){cout<<"B的析构函数"<<endl;}
};int main(int argc, char *argv[])
{DataB ob(10,20);return 0;
}
打印结果:
A的无参构造
B的有参构造
B的析构函数
A的析构函数
类会自动调用成员对象的无参构造。
类想调用成员对象 有参构造 必须使用初始化列表。
使用初始化列表,调用成员对象的有参构造
DataB(int num,int numa):ob(numa)//修改B的有参构造{b=num;cout<<"B的有参构造"<<endl;}
A的有参构造
B的有参构造
B的析构函数
A的析构函数
对象数组
对象数组:本质是数组 数组的每个元素是对象
class DataA{
public :int a;
public:DataA(){cout<<"A的无参构造"<<endl;}DataA(int num){a=num;cout<<"A的有参构造"<<endl;}~DataA(){cout<<"A的析构函数"<<endl;}
};int main(int argc, char *argv[])
{//对象数组 每个元素都会自动调用构造和析构函数//对象数组不会自动初始化 每个元素 调用无参构造
// ataA array[5];//对象数组的初始化 必须显示使用有参构造 逐个元素初始化DataA array[5]={DataA(1),DataA(2),DataA(3),DataA(4),DataA(5)};int len=sizeof(array)/sizeof(array[0]);for(int i=0;i<len;i++){cout<<array[i].a<<" ";}cout<<endl;return 0;
}
A的有参构造
A的有参构造
A的有参构造
A的有参构造
A的有参构造
1 2 3 4 5
A的析构函数
A的析构函数
A的析构函数
A的析构函数
A的析构函数
explicit函数
explicit防止构造函数隐式转换
什么是隐式转换?
class DataA{
public :int a;
public:DataA(){cout<<"A的无参构造"<<endl;}DataA(int num){a=num;cout<<"A的有参构造"<<endl;}~DataA(){cout<<"A的析构函数"<<endl;}
};int main(int argc, char *argv[])
{DataA ob=10;//隐式转换 DataA ob=Data(10);return 0;
}
加上explicit关键字防止隐式转换【new和delete 堆区空间操作
class DataA{
public :int a;
public:DataA(){cout<<"A的无参构造"<<endl;}explicit DataA(int num){a=num;cout<<"A的有参构造"<<endl;}~DataA(){cout<<"A的析构函数"<<endl;}
};int main(int argc, char *argv[])
{DataA ob=10;//errorreturn 0;
}
new和delete 堆区空间操作
1、new和delete操作基本类型的空间
int main(int argc, char *argv[])
{int *p=new int(5);cout<<"*p="<<*p<<endl;delete p;return 0;
}
区别:
new 不用强制类型转换(malloc返回的类型是(void *))
new在申请空间的时候可以 初始化空间内容
new 申请基本类型的数组
int main(int argc, char *argv[])
{int *p=new int[5]{1,2,3,4,5};for(int i=0;i<5;i++){cout<<p[i]<<endl;}delete []p;//delete 数组要加上[]return 0;
}
2、new和delete操作类
malloc不会调用构造函数 free不会调用析构函数
new 会调用构造函数 delete调用析构函数
class DataA{
public :int a;
public:DataA(){cout<<"A的无参构造"<<endl;}explicit DataA(int num){a=num;cout<<"A的有参构造"<<endl;}~DataA(){cout<<"A的析构函数"<<endl;}
};int main(int argc, char *argv[])
{
DataA *p1=new DataA();
DataA *p2=new DataA();
DataA *array=new DataA[5]{DataA(1),DataA(2),DataA(3),DataA(4),DataA(5)};delete p1;//delete
delete p2;
delete[]array;//释放数组的空间return 0;
}
静态成员
类的对象 拥有独立的 普通成员数据。
static 修饰的成员 叫 静态成员
class Data{static int a;//静态成员数据static void func()//静态成员函数{}
①静态成员数据
static修饰的静态成员 属于类而不是对象。(所有对象共享 一份 静态成员数据)
static修饰的成员 定义类的时候 必须分配空间。
static修饰的静态成员数据 必须类中定义 类外初始化。
class DataA{
public :int a;static int b;
public:DataA(){cout<<"A的无参构造"<<endl;}DataA(int num){a=num;cout<<"A的有参构造"<<endl;}
};int DataA::b=100;//类外初始化int main(int argc, char *argv[])
{cout<<DataA::b<<endl;//100DataA *ob=new DataA();cout<<ob.b<<endl;//100ob.b=200;cout<<DataA::b<<endl;//200return 0;
}
静态成员数据统计对象个数
#include <iostream>using namespace std;class DataA{
public :int a;static int count;
public://无参构造DataA(){count++;}//有参构造DataA(int num){a=num;count++;}//拷贝构造DataA(const DataA &ob){a=ob.a;count++;}//析构函数~DataA(){count--;}
};int DataA::count=0;//类外初始化int main(int argc, char *argv[])
{
DataA oba;
DataA obb(10);
DataA obc=oba;
cout<<"对象个数为"<<DataA::count<<endl;return 0;
}
静态成员函数
静态成员函数 是属于类 而不是对象(所有对象共享)
1、静态成员函数可以直接通过类名称访问
2、静态成员函数内只能操作静态成员数据
单例模式
单例模式的类,只能实例化一个对象
1、构造函数私有化
2、定义一个私有的对象指针,保存唯一的实例地址
#include <iostream>using namespace std;class SingleTon{//构造函数私有化
private:SingleTon(){count=0;cout<<"构造"<<endl;}~SingleTon(){cout<<"析构函数"<<endl;}SingleTon(const SingleTon &ob){count=0;cout<<"拷贝构造"<<endl;}private:static SingleTon *const p;int count;public:static SingleTon *getSingleTon(void){return p;}void printStirng(char *str){count++;cout<<"当前第"<<count<<"次任务打印:"<<str<<endl;}};
SingleTon *const SingleTon::p=new SingleTon;int main(int argc, char *argv[])
{SingleTon *p=SingleTon::getSingleTon();p->printStirng("hello");SingleTon *p2=SingleTon::getSingleTon();p2->printStirng("hello");return 0;
}
类的存储结构
类的成员函数和静态变量不占类的内存空间
const修改成员函数为只读
#include <iostream>
#include<string>
#include<stdlib.h>
using namespace std;class DataA{
public :int a;mutable int b;//mutable修饰的成员变量可以修改public:void printString(void) const{//const修饰成员函数为只读
// this->a=100;//在打印函数中修改成员变量 errorcout<<"a="<<a<<endl;this->b=100;cout<<"b="<<b<<endl;}DataA(int a,int b){this->a=a;this->b=b;}
};int main(int argc, char *argv[])
{DataA ob=DataA(10,20);ob.printString();return 0;
}
友元
1、普通全局函数作为类的友元
#include <iostream>
#include<string>using namespace std;class Room{friend void visit(Room &room);//friend关键字
private:string bedRoom;//卧室
public:string setingRoom;//客厅
public://构造函数Room(string bedRoom,string setingRoom){this->bedRoom=bedRoom;this->setingRoom=setingRoom;}};//普通的全局函数
void visit(Room &room){cout<<"访问了"<<room.setingRoom<<endl;cout<<"访问了"<<room.bedRoom<<endl;
}int main(int argc, char *argv[])
{Room room("张三卧室","张三客厅");visit(room);return 0;
}
2、类的某个成员函数 作为另一个类的友元
#include <iostream>
#include<string.h>using namespace std;class Room;//先声明class goodGay{
public:void visit01(Room &room);//先在类中声明,类外实现(否则之前只声明了Room,并没有声明Room中的成员,所以访问不了)void visit02(Room &room);
};class Room{friend void goodGay::visit02(Room &room);//将类中成员函数声明为友元
private:string bedRoom;//卧室
public:string setingRoom;//客厅
public://构造函数Room(string bedRoom,string setingRoom){this->bedRoom=bedRoom;this->setingRoom=setingRoom;}};//类外实现
void goodGay::visit01(Room &room){cout<<"李四访问了"<<room.setingRoom<<endl;}void goodGay::visit02(Room &room){cout<<"好基友张八访问了"<<room.setingRoom<<endl;cout<<"好基友张八访问了"<<room.bedRoom<<endl;}int main(int argc, char *argv[])
{Room room("张三卧室","张三客厅");goodGay ob;ob.visit01(room);ob.visit02(room);return 0;
}
3、 整个类作为友元
这个类的所有成员函数 都可以访问另一个类的私有数据
#include <iostream>
#include<string.h>using namespace std;class Room;//先声明class goodGay{
public:void visit01(Room &room);//先在类中声明,类外实现(否则之前只声明了Room,并没有声明Room中的成员,所以访问不了)void visit02(Room &room);
};class Room{friend class goodGay;private:string bedRoom;//卧室
public:string setingRoom;//客厅
public://构造函数Room(string bedRoom,string setingRoom){this->bedRoom=bedRoom;this->setingRoom=setingRoom;}};void goodGay::visit01(Room &room){cout<<"李四访问了"<<room.setingRoom<<endl;}void goodGay::visit02(Room &room){cout<<"好基友张八访问了"<<room.setingRoom<<endl;cout<<"好基友张八访问了"<<room.bedRoom<<endl;}int main(int argc, char *argv[])
{Room room("张三卧室","张三客厅");goodGay ob;ob.visit01(room);ob.visit02(room);return 0;
}
注意
1.友元关系不能被继承。
2.友元关系是单向的,类A是类B的朋友,但类B不一定是类A的朋友。
3.友元关系不具有传递性。类B是类A的朋友,类C是类B的朋友,但类C不一定是类A的朋友
设计动态数组类
Array.h
#ifndef ARRAY_H
#define ARRAY_H
class Array{
private:int *arr;//存放首地址元素int capacity;//容量int size;//大小public:Array();Array(int capacity);Array(const Array &ob);~Array();int getCapacity() const;//get容量int getSize() const;//getSizevoid printArray(void);//打印数组void pushBack(int elem);//从尾部插入数据void popBack(void);//删除尾部元素int &at(int pos);//获取元素,并返回引用类型};#endif // ARRAY_H
array.cpp
#include "array.h"
#include "string.h"
#include <iostream>
using namespace std;
Array::Array(){capacity=5;size=0;arr=new int[capacity];memset(arr,0,sizeof(int)*capacity);}
Array::Array(const Array &ob){capacity=ob.capacity;size=ob.size;arr=new int[capacity];memcpy(arr,ob.arr,sizeof(int)*capacity);}
Array::~Array(){if(arr!=NULL){delete[]arr;arr=NULL;}
}
int Array::getCapacity()const{return capacity;
}
int Array::getSize()const{return size;
}
void Array::pushBack(int elem){if(size==capacity){int *temp=new int[2*capacity];memcpy(temp,arr,sizeof(int)*capacity);delete[]arr;arr=temp;capacity=2*capacity;}arr[size++]=elem;return;
}
void Array::popBack(){if(size==0){cout<<"容量为空"<<endl;}else{size--;}return;
}
int &Array::at(int pos){if(pos<0||pos>=size){cout<<"访问违法内存"<<endl;exit(-1);}return arr[pos];
}
void Array::printArray(void){for(int i=0;i<size;i++){cout<<arr[i]<<" ";}cout<<endl;
}
main.cpp
#include "array.h"
#include <iostream>
using namespace std;int main(int argc, char *argv[])
{
Array array;
array.pushBack(10);
array.pushBack(20);
array.pushBack(30);
array.pushBack(40);
array.printArray();
array.at(2)=100;
array.printArray();return 0;
}
相关文章:

类和对象(提高)
类和对象(提高) 1、定义一个类 关键字class 6 class Data1 7 { 8 //类中 默认为私有 9 private: 10 int a;//不要给类中成员 初始化 11 protected://保护 12 int b; 13 public://公共 14 int c; 15 //在类的内部 不存在权限之分 16 void showData(void)…...

免费最好用的证件照制作软件,一键换底+老照片修复+图片动漫化,吊打付费!
这款软件真的是阿星用过的,最好用的证件照制作软件,没有之一! 我是阿星,今天要给大家安利一款超实用的证件照工具,一键换底,自动排版,免费无广告,让你在家就能轻松搞定证件照&#…...

antfu/ni 在 Windows 下的安装
问题 全局安装 ni 之后,第一次使用会有这个问题 解决 在 powershell 中输入 Remove-Item Alias:ni -Force -ErrorAction Ignore之后再次运行 ni Windows 11 下的 Powershell 环境配置 可以参考 https://github.com/antfu-collective/ni?tabreadme-ov-file#how …...

Linux 生产消费者模型
💓博主CSDN主页:麻辣韭菜💓 ⏩专栏分类:Linux初窥门径⏪ 🚚代码仓库:Linux代码练习🚚 🌹关注我🫵带你学习更多Linux知识 🔝 前言 1. 生产消费者模型 1.1 什么是生产消…...
深入浅出:MongoDB中的背景创建索引
深入浅出:MongoDB中的背景创建索引 想象一下,你正忙于将成千上万的数据塞入你的MongoDB数据库中,你的用户期待着实时的响应速度。此时,你突然想到:“嘿,我应该给这些查询加个索引!” 没错&…...
Spring事务十种失效场景
首先我们要明白什么是事务?它的作用是什么?它在什么场景下在Spring框架下会失效? 事务:本质上是由数据库和程序之间交互的过程中的衍生物,它是一种控制数据的行为规则。有几个特性 1、原子性:执行单元内,要…...

JELR-630HS漏电继电器 30-500mA 导轨安装 约瑟JOSEF
JELR-HS系列 漏电继电器型号: JELR-15HS漏电继电器;JELR-25HS漏电继电器; JELR-32HS漏电继电器;JELR-63HS漏电继电器; JELR-100HS漏电继电器;JELR-120HS漏电继电器; JELR-160HS漏电继电器&a…...
如何实现一个简单的链表或栈结构
实现一个简单的链表或栈结构是面向对象编程中的基础任务。下面我将分别给出链表和栈的简单实现。 链表(单链表)的实现 链表是由一系列节点组成的集合,每个节点都包含数据部分和指向列表中下一个节点的链接(指针或引用࿰…...

抖音外卖服务商入驻流程及费用分别是什么?入驻官方平台的难度大吗?
随着抖音关于新增《【到家外卖】内容服务商开放准入公告》的意见征集通知(以下简称“通知”)的发布,抖音外卖服务商入驻流程及费用逐渐成为众多创业者所关注和热议的话题。不过,就当前的讨论情况来看,这个话题似乎没有…...

“小红书、B站崩了”,背后的阿里云怎么了?
导语:阿里云不能承受之重 文 | 魏强 7月2日,“小红书崩了”、“B站崩了”等话题登上了热搜。 据第一财经、财联社等报道,7月2日,用户在B站App无法使用浏览历史关注等内容,消息界面、更新界面、客服界面均不可用&…...

nginx的配置文件
nginx.conf 1、全局模块 worker_processes 1; 工作进程数,设置成服务器内核数的2倍(一般不超过8个,超过8个反正会降低性能,4个 1-2个 ) 处理进程的过程必然涉及配置文件和展示页面,也就是涉及打开文件的…...
艾滋病隐球菌病的病原学诊断方法包括?
艾滋病隐球菌病的病原学诊断方法包括()查看答案 A.培养B.隐球菌抗原C.墨汁染色D.PCR 在感染性疾病研究中,单细胞转录组学的应用包括哪些()? A.细胞异质性研究B.基因组突变检测C.感染过程单细胞分析D.代谢通路分析 开展病原微生物网络实验室体系建设,应通…...
jQuery Tooltip 插件使用教程
jQuery Tooltip 插件使用教程 引言 jQuery Tooltip 插件是 jQuery UI 套件的一部分,它为网页元素添加了交互式的提示框功能。通过这个插件,开发者可以轻松地为链接、按钮、图片等元素添加自定义的提示信息,从而增强用户的交互体验。本文将详细介绍如何使用 jQuery Tooltip…...
访问者模式在金融业务中的应用及其框架实现
引言 访问者模式(Visitor Pattern)是一种行为设计模式,它允许你在不改变对象结构的前提下定义作用于这些对象的新操作。通过使用访问者模式,可以将相关操作分离到访问者中,从而提高系统的灵活性和可维护性。在金融业务…...
.npy格式图像如何进行深度学习模型训练处理,亲测可行
import torchimport torch.nn as nnimport torch.nn.functional as Fimport numpy as npfrom torch.utils.data import DataLoader, Datasetfrom torchvision import transformsfrom PIL import Imageimport json# 加载训练集和测试集数据train_images np.load(../dataset/tra…...
XFeat快速图像特征匹配算法
XFeat(Accelerated Features)是一种新颖的卷积神经网络(CNN)架构,专为快速和鲁棒的像匹配而设计。它特别适用于资源受限的设备,同时提供了与现有深度学习方法相比的高速度和准确性。 轻量级CNN架构…...

普元EOS学习笔记-低开实现图书的增删改查
前言 在前一篇《普元EOS学习笔记-创建精简应用》中,我已经创建了EOS精简应用。 我之前说过,EOS精简应用就是自己创建的EOS精简版,该项目中,开发者可以进行低代码开发,也可以进行高代码开发。 本文我就记录一下自己在…...

动态住宅代理IP详细解析
在大数据时代的背景下,代理IP成为了很多企业顺利开展的重要工具。代理IP地址可以分为住宅代理IP地址和数据中心代理IP地址。选择住宅代理IP的好处是可以实现真正的高匿名性,而使用数据中心代理IP可能会暴露自己使用代理的情况。 住宅代理IP是指互联网服务…...

等保2.0 实施方案之信息软件验证要求
一、等保2.0背景及意义 随着信息技术的快速发展和网络安全威胁的不断演变,网络安全已成为国家安全、社会稳定和经济发展的重要保障。等保2.0(即《信息安全技术 网络安全等级保护基本要求》2.0版本)作为网络安全等级保护制度的最新标准&#x…...

【LeetCode的使用方法】
🎥博主:程序员不想YY啊 💫CSDN优质创作者,CSDN实力新星,CSDN博客专家 🤗点赞🎈收藏⭐再看💫养成习惯 ✨希望本文对您有所裨益,如有不足之处,欢迎在评论区提出指正,让我们共同学习、交流进步! 🔮LeetCode的使用方法 🔮LeetCode 是一个在线编程平台,广泛…...

Linux 文件类型,目录与路径,文件与目录管理
文件类型 后面的字符表示文件类型标志 普通文件:-(纯文本文件,二进制文件,数据格式文件) 如文本文件、图片、程序文件等。 目录文件:d(directory) 用来存放其他文件或子目录。 设备…...

大话软工笔记—需求分析概述
需求分析,就是要对需求调研收集到的资料信息逐个地进行拆分、研究,从大量的不确定“需求”中确定出哪些需求最终要转换为确定的“功能需求”。 需求分析的作用非常重要,后续设计的依据主要来自于需求分析的成果,包括: 项目的目的…...

从WWDC看苹果产品发展的规律
WWDC 是苹果公司一年一度面向全球开发者的盛会,其主题演讲展现了苹果在产品设计、技术路线、用户体验和生态系统构建上的核心理念与演进脉络。我们借助 ChatGPT Deep Research 工具,对过去十年 WWDC 主题演讲内容进行了系统化分析,形成了这份…...
k8s从入门到放弃之Ingress七层负载
k8s从入门到放弃之Ingress七层负载 在Kubernetes(简称K8s)中,Ingress是一个API对象,它允许你定义如何从集群外部访问集群内部的服务。Ingress可以提供负载均衡、SSL终结和基于名称的虚拟主机等功能。通过Ingress,你可…...
day52 ResNet18 CBAM
在深度学习的旅程中,我们不断探索如何提升模型的性能。今天,我将分享我在 ResNet18 模型中插入 CBAM(Convolutional Block Attention Module)模块,并采用分阶段微调策略的实践过程。通过这个过程,我不仅提升…...

中南大学无人机智能体的全面评估!BEDI:用于评估无人机上具身智能体的综合性基准测试
作者:Mingning Guo, Mengwei Wu, Jiarun He, Shaoxian Li, Haifeng Li, Chao Tao单位:中南大学地球科学与信息物理学院论文标题:BEDI: A Comprehensive Benchmark for Evaluating Embodied Agents on UAVs论文链接:https://arxiv.…...
Cesium1.95中高性能加载1500个点
一、基本方式: 图标使用.png比.svg性能要好 <template><div id"cesiumContainer"></div><div class"toolbar"><button id"resetButton">重新生成点</button><span id"countDisplay&qu…...
大语言模型如何处理长文本?常用文本分割技术详解
为什么需要文本分割? 引言:为什么需要文本分割?一、基础文本分割方法1. 按段落分割(Paragraph Splitting)2. 按句子分割(Sentence Splitting)二、高级文本分割策略3. 重叠分割(Sliding Window)4. 递归分割(Recursive Splitting)三、生产级工具推荐5. 使用LangChain的…...
测试markdown--肇兴
day1: 1、去程:7:04 --11:32高铁 高铁右转上售票大厅2楼,穿过候车厅下一楼,上大巴车 ¥10/人 **2、到达:**12点多到达寨子,买门票,美团/抖音:¥78人 3、中饭&a…...

CocosCreator 之 JavaScript/TypeScript和Java的相互交互
引擎版本: 3.8.1 语言: JavaScript/TypeScript、C、Java 环境:Window 参考:Java原生反射机制 您好,我是鹤九日! 回顾 在上篇文章中:CocosCreator Android项目接入UnityAds 广告SDK。 我们简单讲…...