1. 全栈程序员必看首页

二次与三次B样条曲线c++实现

全栈程序员-用户IM • • 未分类

二次与三次B样条曲线c++实现B样条曲线构建一条平滑曲线，接近而不通过控制点（首尾点除外）。如图B样条曲线从Bezier曲线演变而来，了解B样条曲线首先得了解Bezier曲线。对于平面上的三个点P0，P1，P2，其坐标分别是(x0,y0)、(x1,y1)、(x2,y2)。二次Bezier曲线用一…

大家好，又见面了，我是你们的朋友全栈君。

     B样条曲线构建一条平滑曲线，接近而不通过控制点（首尾点除外）。如图

                                                                   二次与三次B样条曲线c++实现

     B样条曲线从Bezier曲线演变而来，了解B样条曲线首先得了解Bezier曲线。对于平面上的三个点P0，P1，P2，其坐标分别是(x0,y0)、(x1,y1)、(x2,y2)。二次Bezier曲线用一条抛物线进行拟合，其参数方程是

                                  二次与三次B样条曲线c++实现           二次与三次B样条曲线c++实现

    二次Bezier曲线有如下要求：（1）t=0时，曲线经过P0，并与P0P1相切；（2）t=1时，曲线经过P2，并与P1P2相切。即有

                                               二次与三次B样条曲线c++实现

    联立这些条件可以得到曲线参数表达式：

                                                二次与三次B样条曲线c++实现

   其中，二次与三次B样条曲线c++实现，称为二次Bezier曲线基函数。

   每3个离散点形成一条Bezier曲线，由于每条Bezier都经过端点，导致分段的Bezier曲线在端点处难以平滑过渡。二次B样条曲线克服了这个缺点，把端点移到线段中点（如下图所示），这样就能保证各段曲线在连接处能够一阶导数连续。

                         二次与三次B样条曲线c++实现    二次与三次B样条曲线c++实现

    由此满足条件：

                                                   二次与三次B样条曲线c++实现

    结合条件可以求解得到二次B样条曲线：

                                                   二次与三次B样条曲线c++实现

    二次B样条曲线实现，只需将曲线参数t划分成k等分，t从0开始取值，间隔dt，直至k*dt。如果想让整条曲线两端与起始点P0和终止点Pn重合，只需以P0和Pn为中点，构造新点PP1=2*P0-P1，与PP2=2*Pn-Pn-1，替换掉P0与Pn即可。

    三次B样条曲线通过样条基函数可以得到如下形式：

                                                  二次与三次B样条曲线c++实现

    三次B样条具有以下物理意义，曲线起点S位于三角形P0P1P2的中线P1M1上，距离P1点1/3倍P1M1处；曲线中点E位于三角形P1P2P3的中线P2M2上，距离1/3倍P2M2处；曲线起点切线平行于P0P2，终点切线平行于P1P3.

                                                          二次与三次B样条曲线c++实现

   三次B样条曲线要想让曲线两端与起始端P0与Pn重合，只需构造新点PP1=2*P0-P1，与PP2=2*Pn-Pn-1，分别加到P0之前与Pn之后即可。由此，参与计算点的增加了2个（注意，二次B样条是替换不是增加）。

编程实现：

程序实现了二次与三次B样条曲线，封装成了BSpline类

BSpine.h

#pragma once
//#include "position.h"

typedef struct tagPosition
{
    double  x;
    double  y;
	tagPosition(double _x,double _y) { x=_x; y=_y;}
	tagPosition() {};
	bool operator==(const tagPosition & pt) { return (x==pt.x && y==pt.y);} 
} CPosition;

class CBSpline
{
public:
	CBSpline(void);
	~CBSpline(void);

	void TwoOrderBSplineSmooth(CPosition *pt,int Num);
	void TwoOrderBSplineInterpolatePt(CPosition *&pt,int &Num,int *InsertNum);
	double F02(double t);
	double F12(double t);
	double F22(double t);

	void ThreeOrderBSplineSmooth(CPosition *pt,int Num);
	void ThreeOrderBSplineInterpolatePt(CPosition *&pt,int &Num,int *InsertNum);
	double F03(double t);
	double F13(double t);
	double F23(double t);
	double F33(double t);
};

BSpine.cpp

//****************************     BSpline.cpp     *********************************** 
// 包含功能：二次B样条平滑，三次B样条平滑；二次B样条平滑后节点插值
//
// 作者：    蒋锦朋   1034378054@qq.com
// 单位：    中国地质大学（武汉） 地球物理与空间信息学院
// 日期：    2014/12/03
//*************************************************************************************
#include "StdAfx.h"
#include "BSpline.h"


CBSpline::CBSpline(void)
{
}


CBSpline::~CBSpline(void)
{
}
//======================================================================
// 函数功能： 二次B样条平滑，把给定的点，平滑到B样条曲线上，不增加点的数目
// 输入参数： *pt ：给定点序列，执行完成后，会被替换成新的平滑点
//            Num：点个数
// 返回值：   无返回值

// 编辑日期：    2014/12/03
//======================================================================
void CBSpline::TwoOrderBSplineSmooth(CPosition *pt,int Num)
{
	CPosition *temp=new CPosition[Num];
	for(int i=0;i<Num;i++)
		temp[i]=pt[i];

	temp[0].x=2*temp[0].x-temp[1].x;                  //  将折线两端点换成延长线上两点
	temp[0].y=2*temp[0].y-temp[1].y;

	temp[Num-1].x=2*temp[Num-1].x-temp[Num-2].x;
	temp[Num-1].y=2*temp[Num-1].y-temp[Num-2].y;

	CPosition NodePt1,NodePt2,NodePt3;
	double t;
    for(int i=0;i<Num-2;i++)
	{
		NodePt1=temp[i]; NodePt2=temp[i+1]; NodePt3=temp[i+2];
		if(i==0)                                     //  第一段取t=0和t=0.5点
		{   
			t=0;
			pt[i].x=F02(t)*NodePt1.x+F12(t)*NodePt2.x+F22(t)*NodePt3.x;
			pt[i].y=F02(t)*NodePt1.y+F12(t)*NodePt2.y+F22(t)*NodePt3.y;
			t=0.5;
			pt[i+1].x=F02(t)*NodePt1.x+F12(t)*NodePt2.x+F22(t)*NodePt3.x;
			pt[i+1].y=F02(t)*NodePt1.y+F12(t)*NodePt2.y+F22(t)*NodePt3.y;
		}else if(i==Num-3)                          //  最后一段取t=0.5和t=1点
		{
			t=0.5;
			pt[i+1].x=F02(t)*NodePt1.x+F12(t)*NodePt2.x+F22(t)*NodePt3.x;
			pt[i+1].y=F02(t)*NodePt1.y+F12(t)*NodePt2.y+F22(t)*NodePt3.y;
			t=1;
			pt[i+2].x=F02(t)*NodePt1.x+F12(t)*NodePt2.x+F22(t)*NodePt3.x;
			pt[i+2].y=F02(t)*NodePt1.y+F12(t)*NodePt2.y+F22(t)*NodePt3.y;
		}else                                      //  中间段取t=0.5点
		{
			t=0.5;
			pt[i+1].x=F02(t)*NodePt1.x+F12(t)*NodePt2.x+F22(t)*NodePt3.x;
			pt[i+1].y=F02(t)*NodePt1.y+F12(t)*NodePt2.y+F22(t)*NodePt3.y;
		}
	}
	delete []temp;
}

//================================================================
// 函数功能： 二次B样条拟合,在节点之间均匀插入指定个数点
// 输入参数： *pt ：给定点序列，执行完成后，会被替换成新的数据点
//            Num：节点点个数
//            *InsertNum: 节点之间需要插入的点个数指针 
// 返回值：   无返回值
//
// 编辑日期：   2014/12/07
//=================================================================
void CBSpline::TwoOrderBSplineInterpolatePt(CPosition *&pt,int &Num,int *InsertNum)
{
	if(pt==NULL || InsertNum==NULL) return;

	int InsertNumSum=0;                               //  计算需要插入的点总数
	for(int i=0;i<Num-1;i++)  InsertNumSum+=InsertNum[i];

	CPosition *temp=new CPosition[Num];               //  二次B样条不需要增加点数，需要将首尾点替换掉
	for(int i=0;i<Num;i++)
		temp[i]=pt[i];

	temp[0].x=2*temp[0].x-temp[1].x;                  //  将折线两端点换成延长线上两点
	temp[0].y=2*temp[0].y-temp[1].y;

	temp[Num-1].x=2*temp[Num-1].x-temp[Num-2].x;
	temp[Num-1].y=2*temp[Num-1].y-temp[Num-2].y;

	delete []pt;                                      //  点数由原来的Num个增加到Num+InsertNumSum个，删除旧的存储空间，开辟新的存储空间

	pt=new CPosition[Num+InsertNumSum];              

	CPosition NodePt1,NodePt2,NodePt3,NodePt4;        //  两节点间均匀插入点，需要相邻两段样条曲线,因此需要四个节点

	double t;
	int totalnum=0;
	for(int i=0;i<Num-1;i++)                          //  每条线段均匀插入点
	{
		if(i==0)                                      //  第一段只需计算第一条样条曲线，无NodePt1
		{   
			NodePt2=temp[i]; NodePt3=temp[i+1]; NodePt4=temp[i+2];     

			double dt=0.5/(InsertNum[i]+1);
			for(int j=0;j<InsertNum[i]+1;j++)
			{
				t=0+dt*j;
				pt[totalnum].x=F02(t)*NodePt2.x+F12(t)*NodePt3.x+F22(t)*NodePt4.x;
				pt[totalnum].y=F02(t)*NodePt2.y+F12(t)*NodePt3.y+F22(t)*NodePt4.y;
				totalnum++;
			}
		}else if(i==Num-2)                            //  最后一段只需计算最后一条样条曲线，无NodePt4
		{
			NodePt1=temp[i-1]; NodePt2=temp[i]; NodePt3=temp[i+1];

			double dt=0.5/(InsertNum[i]+1);
			for(int j=0;j<InsertNum[i]+2;j++)
			{
				t=0.5+dt*j;
				pt[totalnum].x=F02(t)*NodePt1.x+F12(t)*NodePt2.x+F22(t)*NodePt3.x;
				pt[totalnum].y=F02(t)*NodePt1.y+F12(t)*NodePt2.y+F22(t)*NodePt3.y;
				totalnum++;
			}
		}else                                      
		{
			NodePt1=temp[i-1],NodePt2=temp[i]; NodePt3=temp[i+1]; NodePt4=temp[i+2];    // NodePt1,2,3计算第一条曲线，NodePt2,3,4计算第二条曲线

			int LeftInsertNum,RightInsertNum;          //  计算线段间左右曲线段上分别需要插入的点数
			double rightoffset=0;                      //  左边曲线段从t=0.5开始，又边曲线段从t=rightoffset开始
			double Leftdt=0,Rightdt=0;                 //  左右曲线取点t步长
			if(InsertNum[i]==0 )
			{
				LeftInsertNum=0;
				RightInsertNum=0;
			}else if(InsertNum[i]%2==1)                //  插入点数为奇数，左边曲线段插入点个数比右边多一点
			{
				RightInsertNum=InsertNum[i]/2;
				LeftInsertNum=RightInsertNum+1;
				Leftdt=0.5/(LeftInsertNum);
				Rightdt=0.5/(RightInsertNum+1);
				rightoffset=Rightdt;
			}else                                      //  插入点数为偶数，左右边曲线段插入个数相同
			{
				RightInsertNum=InsertNum[i]/2;
				LeftInsertNum=RightInsertNum;
				Leftdt=0.5/(LeftInsertNum+0.5);
				Rightdt=0.5/(RightInsertNum+0.5);
				rightoffset=Rightdt/2;
			}

			for(int j=0;j<LeftInsertNum+1;j++)
			{
				t=0.5+Leftdt*j;
				pt[totalnum].x=F02(t)*NodePt1.x+F12(t)*NodePt2.x+F22(t)*NodePt3.x;
				pt[totalnum].y=F02(t)*NodePt1.y+F12(t)*NodePt2.y+F22(t)*NodePt3.y;
				totalnum++;
			}

			for(int j=0;j<RightInsertNum;j++)
			{				
				t=rightoffset+Rightdt*j;
				pt[totalnum].x=F02(t)*NodePt2.x+F12(t)*NodePt3.x+F22(t)*NodePt4.x;
				pt[totalnum].y=F02(t)*NodePt2.y+F12(t)*NodePt3.y+F22(t)*NodePt4.y;
				totalnum++;
			}
		}
	}
	delete []temp;
	Num=Num+InsertNumSum;

}
//================================================================
// 函数功能： 二次样条基函数
//
// 编辑日期：    2014/12/03
//================================================================
double CBSpline::F02(double t)
{
	return 0.5*(t-1)*(t-1);
}
double CBSpline::F12(double t)
{
	return 0.5*(-2*t*t+2*t+1);
}
double CBSpline::F22(double t)
{
	return 0.5*t*t;
}
//========================================================================
// 函数功能： 三次B样条平滑，把给定的点，平滑到B样条曲线上，不增加点的数目
// 输入参数： *pt ：给定点序列，执行完成后，会被替换成新的平滑点
//            Num：点个数
// 返回值：   无返回值
//
// 编辑日期：    2014/12/03
//========================================================================
void CBSpline::ThreeOrderBSplineSmooth(CPosition *pt,int Num)
{
	CPosition *temp=new CPosition[Num+2];
	for(int i=0;i<Num;i++)
		temp[i+1]=pt[i];

	temp[0].x=2*temp[1].x-temp[2].x;                  //  将折线延长线上两点加入作为首点和尾点
	temp[0].y=2*temp[1].y-temp[2].y;

	temp[Num+1].x=2*temp[Num].x-temp[Num-1].x;
	temp[Num+1].y=2*temp[Num].y-temp[Num-1].y;

	CPosition NodePt1,NodePt2,NodePt3,NodePt4;
	double t;
	for(int i=0;i<Num-1;i++)
	{
		NodePt1=temp[i]; NodePt2=temp[i+1]; NodePt3=temp[i+2]; NodePt4=temp[i+3];

		if(i==Num-4)                          //  最后一段取t=0.5和t=1点
		{
			t=0;
			pt[i].x=F03(t)*NodePt1.x+F13(t)*NodePt2.x+F23(t)*NodePt3.x+F33(t)*NodePt4.x;
			pt[i].y=F03(t)*NodePt1.y+F13(t)*NodePt2.y+F23(t)*NodePt3.y+F33(t)*NodePt4.y;
			t=1;
			pt[i+1].x=F03(t)*NodePt1.x+F13(t)*NodePt2.x+F23(t)*NodePt3.x+F33(t)*NodePt4.x;
			pt[i+1].y=F03(t)*NodePt1.y+F13(t)*NodePt2.y+F23(t)*NodePt3.y+F33(t)*NodePt4.y;
		}else                                      //  中间段取t=0.5点
		{
			t=0;
			pt[i].x=F03(t)*NodePt1.x+F13(t)*NodePt2.x+F23(t)*NodePt3.x+F33(t)*NodePt4.x;
			pt[i].y=F03(t)*NodePt1.y+F13(t)*NodePt2.y+F23(t)*NodePt3.y+F33(t)*NodePt4.y;
		}
	}
	delete []temp;
}

//================================================================
// 函数功能： 三次B样条拟合,在节点之间均匀插入指定个数点
// 输入参数： *pt ：给定点序列，执行完成后，会被替换成新的数据点
//            Num：节点点个数
//            *InsertNum: 节点之间需要插入的点个数指针 
// 返回值：   无返回值
//
// 编辑日期：   2014/12/07
//=================================================================
void CBSpline::ThreeOrderBSplineInterpolatePt(CPosition *&pt,int &Num,int *InsertNum)
{
	if(pt==NULL || InsertNum==NULL) return;

	int InsertNumSum=0;                               //  计算需要插入的点总数
	for(int i=0;i<Num-1;i++)  InsertNumSum+=InsertNum[i];

	CPosition *temp=new CPosition[Num+2];
	for(int i=0;i<Num;i++)
		temp[i+1]=pt[i];

	temp[0].x=2*temp[1].x-temp[2].x;                  //  将折线延长线上两点加入作为首点和尾点
	temp[0].y=2*temp[1].y-temp[2].y;

	temp[Num+1].x=2*temp[Num].x-temp[Num-1].x;
	temp[Num+1].y=2*temp[Num].y-temp[Num-1].y;

	CPosition NodePt1,NodePt2,NodePt3,NodePt4;
	double t;

	delete []pt;                                      //  点数由原来的Num个增加到Num+InsertNumSum个，删除旧的存储空间，开辟新的存储空间

	pt=new CPosition[Num+InsertNumSum];              

	int totalnum=0;
	for(int i=0;i<Num-1;i++)                          //  每条线段均匀插入点
	{
		NodePt1=temp[i]; NodePt2=temp[i+1]; NodePt3=temp[i+2]; NodePt4=temp[i+3];
		double dt=1.0/(InsertNum[i]+1);

		for(int j=0;j<InsertNum[i]+1;j++)
		{
			t=dt*j;
			pt[totalnum].x=F03(t)*NodePt1.x+F13(t)*NodePt2.x+F23(t)*NodePt3.x+F33(t)*NodePt4.x;
			pt[totalnum].y=F03(t)*NodePt1.y+F13(t)*NodePt2.y+F23(t)*NodePt3.y+F33(t)*NodePt4.y;
			totalnum++;
		}

		if(i==Num-2){              //  最后一个尾点
			t=1;
			pt[totalnum].x=F03(t)*NodePt1.x+F13(t)*NodePt2.x+F23(t)*NodePt3.x+F33(t)*NodePt4.x;
			pt[totalnum].y=F03(t)*NodePt1.y+F13(t)*NodePt2.y+F23(t)*NodePt3.y+F33(t)*NodePt4.y;
			totalnum++;
		}
	}

	delete []temp;
	Num=Num+InsertNumSum;

}

//================================================================
// 函数功能： 三次样条基函数
//
// 编辑日期：    2014/12/03
//================================================================
double CBSpline::F03(double t)
{
	return 1.0/6*(-t*t*t+3*t*t-3*t+1);
}
double CBSpline::F13(double t)
{
	return 1.0/6*(3*t*t*t-6*t*t+4);
}
double CBSpline::F23(double t)
{
	return 1.0/6*(-3*t*t*t+3*t*t+3*t+1);
}
double CBSpline::F33(double t)
{
	return 1.0/6*t*t*t;
}

程序调用：

#include "stdafx.h"
#include "math.h"
#include "BSpline.h"

int _tmain(int argc, _TCHAR* argv[])
{
	int num=8;
	double x[8]={9.59,60.81,105.57,161.59,120.5,100.1,50.0,10.0};
	double y[8]={61.97,107.13,56.56,105.27,120.5,150.0,110.0,180.0};

	CPosition *testpt=new CPosition[num];
	for(int i=0;i<num;i++) testpt[i]=CPosition(x[i],y[i]);

	int *Intnum=new int[num-1]; 
	for(int i=0;i<num-1;i++){
		Intnum[i]=10;                 //  每一个样条曲线内插入10个点
	}

	int num2=num;
	CBSpline bspline;
	bspline.TwoOrderBSplineInterpolatePt(testpt,num2,Intnum);        //  二次B样条曲线
	//bspline.ThreeOrderBSplineInterpolatePt(testpt,num2,Intnum);    //  三次B样条曲线

	//bspline.TwoOrderBSplineSmooth(testpt,num2);      //  二次B样条平滑
	//bspline.ThreeOrderBSplineSmooth(testpt,num2);    //  三次B样条平滑
	delete Intnum;


	FILE *fp_m_x = fopen("Bspline_test_x.txt", "wt");
	FILE *fp_m_y = fopen("Bspline_test_y.txt", "wt");
	for (int i = 0; i < num2; i++){
		fprintf(fp_m_x, "%lf\n", testpt[i].x);
		fprintf(fp_m_y, "%lf\n", testpt[i].y);
	}
	fclose(fp_m_x);
	fclose(fp_m_y);

	return 0;
}

程序运行结束后会生成样条曲线坐标文件，分别为横坐标：Bspline_test_x.txt和纵坐标Bspline_test_y.txt.利用matlab绘图可以得到下面结果： 

                                       二次与三次B样条曲线c++实现

附matlab绘图代码：

clear all;
clc;

load Bspline_test_x2.txt;    % 导入二次B样条计算的结果
load Bspline_test_y2.txt;
load Bspline_test_x3.txt;    % 导入三次B样条计算的结果
load Bspline_test_y3.txt;

load Bspline_test_smooth_x2.txt
load Bspline_test_smooth_y2.txt
load Bspline_test_smooth_x3.txt
load Bspline_test_smooth_y3.txt

control_point_x=[9.59,60.81,105.57,161.59,120.5,100.1,50.0,10.0];
control_point_y=[61.97,107.13,56.56,105.27,120.5,150.0,110.0,180.0];

figure;
h1=plot(control_point_x,control_point_y,'--ob'); hold on;
h2=plot(Bspline_test_x2,Bspline_test_y2,'--k','LineWidth',2);
h3=plot(Bspline_test_x3,Bspline_test_y3,':r','LineWidth',2);
h4=plot(Bspline_test_smooth_x2,Bspline_test_smooth_y2,'og','LineWidth',1);
h5=plot(Bspline_test_smooth_x3,Bspline_test_smooth_y3,'^b','LineWidth',1);

legend([h1 h2 h3 h4 h5],'控制点','二次B样条曲线','三次B样条曲线','二次B样条平滑','三次B样条平滑');
axis([0 200 40 200]);
set(gca,'FontSize',15); set(gca,'FontWeight','bold'); set(gca,'LineWidth',2);
set(get(gca,'XLabel'),'Fontsize',15); set(get(gca,'YLabel'),'FontSize',15);

 

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/150364.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

  • LDAP服务器搭建新手指南[通俗易懂]

    LDAP服务器搭建新手指南[通俗易懂]

    LDAP服务器搭建新手指南[通俗易懂]Normal0false7.8

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年5月14日
  • 什么是差分数组？「建议收藏」

    什么是差分数组？「建议收藏」

    什么是差分数组？「建议收藏」问题背景如果给你一个包含5000万个元素的数组，然后会有频繁区间修改操作，那什么是频繁的区间修改操作呢？比如让第1个数到第1000万个数每个数都加上1，而且这种操作时频繁的。此时你应该怎么做？很容易想到的是，从第1个数开始遍历，一直遍历到第1000万个数，然后每个数都加上1，如果这种操作很频繁的话，那这种暴力的方法在一些实时的系统中可能就拉跨了。因此，今天的主角就出现了——差分数组。…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年4月28日
  • 分布式锁的应用场景和三种实现方式的区别_负载均衡策略

    分布式锁的应用场景和三种实现方式的区别_负载均衡策略

    分布式锁的应用场景和三种实现方式的区别_负载均衡策略多线程对同一资源的竞争，需要用到锁，例如Java自带的Synchronized、ReentrantLock。但只能用于单机系统中，如果涉及到分布式环境（多机器）的资源竞争，则需要分布式锁。分布式锁的主要作用：保证数据的正确性：比如：秒杀的时候防止商品超卖，表单重复提交，接口幂等性。避免重复处理数据：比如：调度任务在多台机器重复执行，缓存过期所有请求都去加载数据库。分布式锁的主要特性：互斥：同一时刻只能有一个线程获得锁。可重入：当一个线程获取锁后，还可以再次获取这个锁，避免死锁发生。高可用：当

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年9月8日
  • 关于PHP的内置服务器的使用

    关于PHP的内置服务器的使用

    关于PHP的内置服务器的使用

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年10月17日
  • ROS编译 Python 文件(详细说明)

    ROS编译 Python 文件(详细说明)

    ROS编译 Python 文件(详细说明)

    全栈程序员-用户IM 全栈程序员-用户IM
    2020年11月8日
  • 计算机全选的键盘,全选快捷键是什么,教您电脑全选快捷键是什么[通俗易懂]

    计算机全选的键盘,全选快捷键是什么,教您电脑全选快捷键是什么[通俗易懂]

    计算机全选的键盘,全选快捷键是什么,教您电脑全选快捷键是什么[通俗易懂]我们在编辑内容的时候难免会遇到全选快捷键的使用，如果使用鼠标容易出错，又不方便，如果使用全选快捷键会不会方便呢？那么全选快捷键是什么？怎么快速全选文件呢?下面，小编给大家分享电脑全选快捷键的操作按键。在日常的工作中，快捷键的使用能提高我们的工作速度，因此我们会去记住一些快捷键以方便使用。不少人在编辑文字的时候，想要使用全选快捷键，但是却不知道要按键盘哪几个键，下面，小编就来跟大家介绍电脑全选快捷键…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年5月9日

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号