【经验杂谈1】

已于 2024-05-20 16:26:17 修改
阅读量128 收藏
点赞数 2
文章标签： 笔记
于 2024-04-13 17:21:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79232710/article/details/137718354
版权

按照时间线来写吧：

1.C++1—通讯录项目实战 心得

单链表 和 结构数组 均已实现；

  • C++分配内存问题不要使用C的方式，Book abs = new PersonBook;相当于C语言中的Book abs = malloc(sizeof(struct PersonBook));
  • 删除数组元素直接a[0]＝｛｝；
  • return 可以直接中断函数！
  • 即使是在返回类型为 void 的函数中，可以使用 return; 语句来显式地结束函数的执行，提前退出函数！！！
  • 当使用swap函数来交换两个数组成员的值的时候，虽然数组本身传递了地址，但还是要写上&：
  • 在调用指针之前一定要保证指针的内容是存在的而不是NULL
while(p && p->data != e)//当p存在并且...{}

```c
Swap(&a[j],& a[j + 1]);

2.ChatGPT引路 指向指针的指针

//说白了就是传值和传地址的方式：函数的参数 传地址可以修改变量的值，而只是传值却不能修改（copy），
//你要修改普通变量的值，就要传入普通变量的地址，你要修改指针指向的值，就要传入指针的地址
// 修改指针指向的值
void changePointer(int** ptr)//int** 表示 指向指针 的指针
//int* ：要传入普通变量的地址->传址方式修改普通变量的值
//int** ：要传入的是指针变量的地址->传址方式改变指针变量的值

{
    int newValue = 100;
    *ptr = &newValue; // 修改指针的指向为 newValue 的地址
}

int main() {
    int value = 10;

    /*int* ptr = &value;*/
    int* ptr;
    ptr = &value;
    //这两种写法是等效的；由此可见int* 是一个整体，他代表了指向整形的变量。

    printf("指针原始指向的值：*ptr = %d\n", *ptr);
    printf("指针ptr的值 = %d\n", ptr);//ptr的值是指向变量的地址

    // 调用函数，传入指针的地址
    /*changePointer(&ptr);*/
    int newValue = 100;
    ptr = &newValue;

    printf("指针修改后指向的值：*ptr = %d\n", *ptr); // 输出修改后的值
    printf("指针修改后ptr的值 = %d\n", ptr);

    return 0;
}

3.合并成有序链表 学到的工作流

不要以为写不出某个大的程序而自闭、焦虑；当一个程序较为复杂，包含多个函数与声明的时候，要学会慢慢调试，一个函数一个函数地来进行完善，逐个攻破。

4.关于while、for循环

这俩循环在链表的相关操作中，使用频率较大；要注意，当循环次数未知的时候，使用while循环，当循环次数已知的时候，使用for循环

5. C++头文件 #include <cstring>

  • 在 C++ 中，string 类型的字符串是可变的，可以通过直接再次赋值来改变它的内容；
  • 对于 char[] 类型的字符串，属于全是字符的数组，是一种固定大小的字符序列，可以通过修改数组的各个元素来实现字符串的修改，但是不能直接对整个数组进行赋值操作。
#include <cstring> 中用到的函数：

strcmp(): 用于比较两个字符串是否相等，返回值为 0 表示相等，第一个字符串小，返回负数；第一个字符串大，返回正数。if (strcmp(name1, name2) == 0)
strcpy(): 使用 strcpy() 函数将新的姓名复制到相应的字符数组中，相当于修改字符串（主要是修改字符数组）。strcpy(str, "Hello, World!"); str为要修改的字符串变量。
strstr(): 在一个字符串中搜索指定子字符串的第一次出现，并返回该子字符串在字符串中的位置（指向子字符串的指针）。如果找到了子字符串，则返回指向该子字符串第一次出现的位置的指针（返回的是指针！）；如果未找到，则返回 nullptr

if (result != nullptr) {
        cout << "在字符串中找到了子字符串：" << result << endl;

函数原型：

char *strstr(const char *str1, const char *str2);

6.DS实验1—顺序栈和链队列的各种操作

  • 注意检查内存分配是否成功
struct Node* Ptr = new(struct Node);
if(Ptr == nullptr)
{
	cout << "分配内存失败" << endl;
	//如果在函数内部
	return ;
}
  • C++中使用new字符动态分配内存
    分配结构指针内存：struct Node* = new(struct Node);
    分配指定大小的数组内存：int* arr = new int [num];//num可以是常量也可以是变量
  • if if-else的使用情况：函数内return可用时，if判断不满足直接结束函数；if语句 下面的语句：不论是否满足if，(如果没有return)执行之后一定会执行；if语句后面的else语句，如果不满足if语句才会执行；
  • 注意有分配内存，在程序的最后就得有内存的释放！new、delete
  • 避免悬挂指针 ：当一个指针指向的内存位置被删除（或释放）后，这个指针就变成了悬挂指针。
    这种情况可能导致意外的程序行为，要防止悬挂指针的出现，需要确保在释放内存之后更新所有相关的指针，通常是将它们设置为 nullptr。
  • 完整代码
#include<iostream>
using namespace std;
#define MaxSize 50
//顺序栈的初始化
struct SNode {
	int Top;//栈顶元素的下标索引
	int Data[MaxSize];
};
typedef struct SNode* Stack;
//链队列的初始化和建立
struct Node//这是链队列中每个节点的结构 
{
	int Data;
	struct Node* Next;
};
struct QNode//链队列的结构
{
	struct Node* front;//这里Front和rear里面不储存数据，只使用指示作用
	struct Node* rear;
};
typedef struct QNode* Queue;

void ShowStackMenu();
void ShowQueueMenu();
void Push(Stack PtrS, int item);
void Pop(Stack PtrS);
void GetTop(Stack PtrS);
void TravelStack(Stack PtrS);
void Clear(Stack PtrS);
void AddQ(Queue PtrQ, int item);
void DeleteQ(Queue PtrQ);
void TravelQueue(Queue PtrQ);
int Length(Queue PtrQ);
void FreeQ(Queue PtrQ);


int main()
{
	//创建一个空队列
	Stack S = new(struct SNode);
	if (S == nullptr)
	{
		cout << "内存分配失败" << endl;
		return -1 ;
	}
	S->Top = -1;//初始化
	
	//创建一个空队列
	Queue Q = new(struct QNode);
	if (Q == nullptr)
	{
		cout << "内存分配失败" << endl;
		return -1;
	}
	Q->front = nullptr;
	Q->rear = nullptr;//空队列的初始化
	
	bool One = true;
	while (One)
	{
		cout << "%%%%---总菜单---%%%%%" << endl;
		cout << "请选择你要的功能：" << endl;
		cout << "1.堆栈操作" << endl;
		cout << "2.队列操作" << endl;
		cout << "3.判断回文数" << endl;
		cout << "4.退出程序" << endl;
		cout << "%%%%%%%%%%%%%%%%%%%%%" << endl;
		int num1;
		cin >> num1;
		switch (num1)
		{
		case 1://执行堆栈的操作部分
		{
			bool Two = true;
			while (Two)
			{
				ShowStackMenu();
				int num2;
				cin >> num2;
				switch (num2)
				{
				case 1:
					TravelStack(S);
					break;
				case 2:
					cout << "请输入要入栈元素的值：";
					int n;
					cin >> n;
					Push(S, n);
					break;
				case 3:
					Pop(S);
					break;
				case 4:
					GetTop(S);
					break;
				case 5:
					Clear(S);
					break;
				case 6:
					cout << "堆栈程序退出，下次再见！" << endl;
					Two = false;
					break;
				}
				system("pause");
				system("cls");//清屏指令
			}
			break;
		}
		case 2://执行队列部分的程序
		{
			bool Three = true;
			while (Three)
			{
				ShowQueueMenu();
				int num3;
				cin >> num3;
				switch (num3)
				{
				case 1:
					TravelQueue(Q);
					break;
				case 2:
					cout << "请输入入队列的元素值：";
					int m;
					cin >> m;
					AddQ(Q, m);
					break;
				case 3:
					DeleteQ(Q);
					break;
				case 4:
					cout << "队列的长度为：" << Length(Q) << endl;
					break;
				case 5:
					Three = false;
					//即将退出程序，释放内存
					FreeQ(Q);//这个函数这是释放了队列中结点的内存，
					//注意不要在这里紧跟着delete(Q)，因为后续还可能继续执行队列操作
					cout << "队列程序退出，下次再见！" << endl;
					break;
				}
				system("pause");
				system("cls");//清屏指令
			}
			break;
		}
		case 3://根据特性，堆栈适合判断回文数
		{
			Clear(S);//操作之前先置空堆栈
			cout << "请输入你要判断的数字的位数：";
			int sum1;
			cin >> sum1;
			cout << endl;
			int* a = new int[sum1];
			cout << "请输入你要判断的数字（每一位使用空格隔开）：";
			for (int i = 0; i < sum1; i++)
			{
				cin >> a[i];//将输入的每一位数按顺序直接储存到数组
				Push(S, a[i]);
			}
			bool status = true;
			for (int j = 0; j < sum1; j++)
			{
				if (a[j] == S->Data[(S->Top)--]/*取栈顶元素*/)
					continue;
				else
				{
					status = false;
					break;
				}
			}
			if (status == true)
				cout << "这个数是回文数" << endl;
			else
				cout << "这个数不是回文数" << endl;
			delete[] a;//释放内存
			system("pause");
			system("cls");//清屏指令
			break;
		}
		case 4://退出程序
			cout << "程序已退出，下次见！" << endl;
			delete(Q);//在整个程序退出后，释放队列结构Q本身的内存
			One = false;
			break;
		}
	}
	return 0;
}

void ShowStackMenu()
{
	cout << "####---堆栈菜单---####" << endl;
	cout << "请选择要执行的操作：" << endl;
	cout << "1.显示栈中所有元素" << endl;
	cout << "2.入栈" << endl;
	cout << "3.出栈" << endl;
	cout << "4.取栈顶元素" << endl;
	cout << "5.置空栈" << endl;
	cout << "6.退出程序" << endl;
	cout << "######################" << endl;
}
void ShowQueueMenu()
{
	cout << "#####---队列菜单---#####" << endl;
	cout << "请选择要执行的操作：" << endl;
	cout << "1.显示队列所有元素" << endl;
	cout << "2.入队列" << endl;
	cout << "3.出队列" << endl;
	cout << "4.求队列的长度" << endl;
	cout << "5.退出程序" << endl;
	cout << "#######################" << endl;
}

//入栈
void Push(Stack PtrS, int item)
{
	//首先判断栈是否已满
	if (PtrS->Top == MaxSize - 1)
	{
		cout << "栈已经满了，无法插入" << endl;
		return;
	}
	PtrS->Data[++(PtrS->Top)] = item;//在栈顶插入新元素
	cout << "入栈成功！" << endl;
}
//出栈，并且返回出栈元素的值
void Pop(Stack PtrS)
{
	//首先判断栈是否为空
	if (PtrS->Top == -1)
	{
		cout << "栈是空的，无法出栈" << endl;
		return ;
	}
	else
	{
		cout << "操作成功，出栈的元素为：" << PtrS->Data[(PtrS->Top)--] << endl;
	}
}
//取栈顶元素
void GetTop(Stack PtrS)
{
	if (PtrS->Top == -1)
	{
		cout << "栈为空,栈顶元素不存在！" << endl;
		return ;
	}
	cout << "栈顶元素为：" <<  PtrS->Data[PtrS->Top] << endl;
}
//遍历顺序栈
void TravelStack(Stack PtrS)
{
	if (PtrS->Top == -1)
	{
		cout << "栈为空！" << endl;
		return;
	}
	int i = 0;
	cout << "栈中所有从栈底到栈顶元素依次为：";
	for (; i <= PtrS->Top; i++)
	{
		cout << PtrS->Data[i] << " ";
	}
	cout << endl;
}
//置空顺序栈
void Clear(Stack PtrS)
{
	if (PtrS->Top == -1)
	{
		cout << "栈为空，无需置空" << endl;
		return;
	}
	int i = 0;
	for (; i <= PtrS->Top; i++)
	{
		PtrS->Data[i] = {};
	}
	PtrS->Top = -1;
	cout << "栈已经置空！" << endl;
}


//入链队列
void AddQ(Queue PtrQ,int item)
{
	struct Node* newNode = new(struct Node);
	if (newNode == nullptr)
	{
		cout << "内存分配失败" << endl;
		return;
	}
	newNode->Data = item;
	newNode->Next = NULL;
	//如果队列为空
	if (PtrQ->front == nullptr)
	{
		PtrQ->front = PtrQ->rear = newNode;
	}
	else
	{
		PtrQ->rear->Next = newNode;
		PtrQ->rear = newNode;
	}
	cout << "入队操作成功！" << endl;
}
//出链队列，删除第一个结点，释放内存，并且打印该节点的值
void DeleteQ(Queue PtrQ)
{
	//先判断是否为空队列
	if (PtrQ->front == nullptr)
	{
		cout << "队列为空，无法出列" << endl;
		return ;
	}
	else
	{
		struct Node* Front = PtrQ->front;
		int copy = Front->Data;
		//考虑只有一个节点的情况
		if (PtrQ->front == PtrQ->rear)
		{
			PtrQ->front = PtrQ->rear = nullptr;
		}
		else
		{//如果大于一个节点，那么就不用管rear
			PtrQ->front = Front->Next;
		}
		delete(Front);
		cout << "操作成功，出队的元素为:" << copy << endl;
	}
}
//遍历链队列
void TravelQueue(Queue PtrQ)
{
	if (PtrQ->front == nullptr)
	{
		cout << "队列为空" << endl;
		return;
	}
	struct Node* temp = PtrQ->front;
	cout << "队列中所有元素为：";
	while (temp != PtrQ->rear)
	{
		cout << temp->Data << " ";
		temp = temp->Next;
	}
	cout << temp->Data << endl;
}
//求队列长度
int Length(Queue PtrQ)
{
	int length = 0;
	struct Node* temp = PtrQ->front;
	while (temp != nullptr)
	{
		length++;
		temp = temp->Next;
	}
	return length;
}
//释放队列中节点内存
void FreeQ(Queue PtrQ)
{
	struct Node* temp = PtrQ->front;//从前向后释放节点
	while (temp != nullptr)
	{
		PtrQ->front = PtrQ->front->Next;//先移动front，引导temp
		delete(temp);
		temp = PtrQ->front;
		//最后的情况应该是front和temp都是空指针nullptr了
	}
	PtrQ->rear = nullptr;//最后避免悬挂指针
}

7.关于指向指针的指针以及数组的指针用法

  1. int *：这是一个指向整数的指针。
  2. int **：这是一个指向指针的指针，可以用来指向一个int *类型的变量。
  3. 在函数调用中，如果以数组名Input作为参数传入，实际上传入的是数组首个元素的指针，地址是第一个元素的地址。这种情况对应*int。
  4. 当对数组名取地址&Input时，得到的是整个数组的地址，地址类型是指向整个数组的指针。它属于二阶（指向指针的指针）因为数组也相当于特殊的指针。这种情况对应**int。
  5. 如果只是需要一个指向首元素地址的指针，以上两种方法都可以，使用第一种即可，便于理解。
  6. 传入指向指针的指针 (int **input)：这种方式允许函数内部改变指针本身的值，也就是改变指针的指向。
  7. 在传入数组作为参数的时候会有些难以理解。
TreeNode* buildTree(int *input, int *index) {
    // 当前索引指向-1，表示这是一个空节点
    if (input[*index] == -1) {
        (*index)++;  // 移动到下一个索引
        return NULL;
    }

    // 不是空节点，创建一个新的树节点
    TreeNode *node = createNode(input[*index]);
    (*index)++;  // 移动到下一个索引

    // 递归构建左子树
    node->left = buildTree(input, index);
    // 递归构建右子树
    node->right = buildTree(input, index);

    return node; // 返回创建的树节点
}

在这个例子中，
input 是一个指向数组首元素的指针。
*input 解引用该指针，得到数组的第一个元素的值。
input[i] 访问数组中索引为 i 的元素，这等价于 *(input + i)。

8.头歌作业—循环队列的操作（基于数组）

struct SqQueue
{
    int *base; // 初始化的动态分配存储空间
    int front;        // 头指针，若队列不空，指向队列头元素
    int rear;         // 尾指针，若队列不空，指向队列尾元素的下一个位置
};
  • base数组是以基地址指针的形式定义的，初始化操作：
Q.base = (int *)malloc(MAX_QSIZE * sizeof(int));
  • 释放base内存的操作：
void DestroyQueue(SqQueue &Q)
{ // 销毁队列Q，Q不再存在
    if (Q.base)
    {
        free(Q.base);//直接free,因为base定义的方式可以理解为变量，直接使用释放变量的方式释放base
        Q.base = NULL;
    }
    Q.front = Q.rear = 0;
}
  • 计算队列长度
int QueueLength(SqQueue Q)
{ // 返回Q的元素个数，即队列的长度
    return (Q.rear - Q.front + MAX_QSIZE) % MAX_QSIZE;//!!!!!
}
  • 入队
int EnQueue(SqQueue &Q, QElemType e)
{ // 插入元素e为Q的新的队尾元素
    if ((Q.rear + 1) % MAX_QSIZE == Q.front) // 队列满
        return ERROR;
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % MAX_QSIZE;
    return OK;
}

这个Q.rear = (Q.rear + 1) % MAX_QSIZE;是防止假溢出，rear+1是平时的操作，如果后边排满了，再对MAX_QSIZE取余，表示从数组前部分开始排；

  • 关于删除的操作
    基于数组实现的队列，在实现删除元素或者置空队列的时候，无需真的删除元素所在，只要移动front和rear就好，因为后续如果再次需要赋值，就直接覆盖掉原来元素的值。

9.关于条件语句

使用if语句时，不必关注所有情况，只需要将要求的情况做出对应的操作即可。

if(n != 0)
{
...
}

只是考虑n不等于0的情况，其他情况不做操作。

donotdothat
关注
软件性能测试中的一些经验杂谈
03-23
软件软件性能测试中的一些经验杂谈软件测试1、数据库的规划初期尽可能的建立好规范和数据索引;2、多层嵌套的sql语句，当多次循环查询，sql语句的性能好坏受sql语句的影响是很大的，避免多余的和错误的循环嵌套;3、...
程序设计经验杂谈
10-06
"程序设计经验杂谈"这个主题旨在分享程序员们在实践中积累的各种经验和技巧，帮助新手和有经验的开发者更好地理解和优化他们的编程实践。 首先，我们来探讨一下程序设计的基本原则。程序设计的核心是解决问题，这...
无线射频电路开发经验杂谈
03-23
本文作者基于近20年的实践经验，分享了关于无线射频电路开发，特别是对讲机射频电路设计的经验和理解。 首先，作者提到了对讲机的简易框图，这是无线通信设备的基础结构，包括信号源、调制器、功率放大器和天线等...
程序员经验杂谈.
05-23
51CTO下载-程序员经验杂谈.ppt
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 921
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
haidizym的博客
10-02 542
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
强化学习笔记之【DDPG算法】
rvdgdsva的博客
10-06 814
强化学习第2篇.强化学习方向的学习者可以参考或者复刻
JAVA Web(学习笔记)
最新发布
m0_74728220的博客
10-09 546
客户端在发送一个请求时，一般而言都会携带一些数据(例如URL中的参数、页面中的表单、Ajax提交的参数等)，当一个Servlet接收到这些请求时，Java Servlet中的类通过所提供的方法就能得到这些参数，也正是这个原因，Servlet可以对发送请求起到拦截作用，它在某些请求前先做一个预处理分析，从而判断客户端是否可以做某些请求，当Servlet具有如上功能时，一般称之为拦截器。Servlet起到这个中间角色的功能，协调各组件、各部分完成相应的功能，根据不同的请求做出相应的响应并显示结果。
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 810
排序是将多个数据，依指定的顺序进行排列的过程。
【数学分析笔记】第4章第4节 复合函数求导法则及其应用（2）
随手写写
10-05 785
【例4.4.3】ye1cosx​，求y′【解】y′e1cosx​⋅21cosx​1​⋅−sinx−21cosx​sinx​e1cosx​yfxuxvx两边取对数得lnylnfxvxlnux等式两边同时对x求导得y1​y′uxvx1​y′v′xlnuxuxvx​u′xy′xuxvxv′xln。
大模型笔记05--coze经典案例分析
脚步不能达到的地方，眼光可以达到；眼光不能达到的地方，精神可以飞到
10-03 871
扣子是新一代 AI 应用开发平台，具备完善的生态系统，是国内最出色的AI平台之一。用好coze平台，不仅可以让我们做出很多有意思的AI产品，还能让我们在AI时代走得更远。本文依托coze平台强大的工作流和图像流能力，分析当前知名的流程搭建方式，让我们能快速搭建有趣的工作流和图像流应用，定制有特色的AI智能体。
Spring（学习笔记）
m0_74728220的博客
10-02 1117
context:annotation-config/>是 Spring 配置文件中的一个标签，用于开启注解配置功能。这个标签可以让 Spring 容器识别并处理使用注解定义的 bean。例如，可以使用 @Autowired 注解自动装配 bean，或者使用 @Component 注解将类标记为 bean 等。为什么加载上下文的时候，被包含的Bean它的构造函数的代码会执行呀？好像是很多代码都执行了！！！没有无参构造，有有参构造会报错！也就是说必须要有无参构造！这是为什么呀！
项目-坦克大战学习笔记-控制玩家坦克不超出地图范围
2401_84659046的博客
10-02 607
由于坦克自身有占用像素格，而坦克生成位置是以左上角x,y的点开始生成，所有坦克向下和向右的实际碰撞位置应该是坦克生成位置加上坦自身宽或高，而坦克有四个方向就有4种对象碰撞可能，所以我们在物体对象的父类中声明存储物体宽和高的int类型。if (Fangxiang == fangxiang.Up)//检测坦克目前朝向。//设置父类继承过来的图片对象高。//设置父类继承过来的图片对象宽。}//放置图片对象的高。}//重写方向构造函数，调用传入的方向信息设置图片的宽高信息。
aws(学习笔记第二课) AWS SDK（node js）
sealaugh32的专栏
10-06 864
注意，可以在create server的同时，执行。index.js以及各个lib/*.js。一定要和前面设定的密钥对名字一致。程序入口，定义了以下的功能。，因为可能有些原因，导致。这是前提条件，这里采用。的方式练习，首先安装。
基金好书入门阅读笔记《基金作战笔记：从投基新手到配置高手的进阶之路》1
jackyrongvip的专栏
10-05 750
3%~6%，对应要承担2%~4%的回撤，且持有1年以上实现的概率就很大了。自己定了30%的股票占比，外加10%的上下浮动区间，那么当牛市中股票占比超过40%，我。这里要提醒投资者，很多所谓的“理财公司”以8%，甚至10%以上的收益率为诱饵，承诺保。通常情况下，权益资产的长期年化收益率在8%~10%是一个合理的预期，但要实现这个收。然，买得便宜是关键。熊市里，跌跌不休的每一个交易日都是天将降大任之前的“苦其心志，劳其筋骨，饿其。当然，这里有一个前提就是我们的配置足够均衡，我们深知自己的投资标的不会产。
计算机组成原理（笔记6阵列乘法器、补码阵列乘法器）
m0_72827793的博客
10-03 409
算前求补级输出为，同时乘法运算的时候是绝对值做的运算，而不是两个数的补码做的运算！因为在计算机里，是先有的补码，再做的运算。平时手算过程中我们是进行平行移位，可是在计算机里平行移位，会带来更大的开销，如下图我们可以看到，为此聪明的人，设计了斜移位的计算机。如图，11（1）（1）=1x2的3次方+1x2的2次方+（-1）x2的1次方+（-1）x2的0次方=9。上一章有写关于这个的乘法，当时是自学的，所以不够完美。值得注意的是最后一行用的是平行移位。平时我们计算乘法的时候是手算的。在电路中的实现，如图所示。
NeRF2: Neural Radio-Frequency Radiance Fields 笔记
行码棋
10-02 1169
任务：用 NeRF 对无线信号的传播进行建模，建模完成后可以用NeRF网络生成新位置下的信号。生成的信号用于指纹定位、信道估计等下游任务。
前端学习笔记
weixin_50361560的博客
10-07 1584
hash模式：URL 中带有，兼容性好，不需要服务器配置，适合简单项目。history模式：URL 美观，符合现代应用开发需求，但需要服务器配置支持。abstract模式：用于非浏览器环境，适合服务端渲染或测试。通常情况下，在浏览器应用中，hash模式适合无需服务器配置的项目，而history模式则适合希望有更加美观 URL 的现代应用。Vue 2 使用实现响应式，只能劫持已有的属性，不能检测新增或删除的属性。Vue 3 使用Proxy。
SSH项目经验与技巧分享
1. **jQuery实例**：作者提到了jQuery的基础知识，这包括选择器、事件处理、DOM操作等，jQuery简化了JavaScript的使用，提高了前端开发效率。 2. **数据库篇章**： - **MySQL和SQL Server**：讨论了MySQL客户端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值