写的一个linux客户端操作cmp

最新推荐文章于 2021-05-14 15:55:02 发布
最新推荐文章于 2021-05-14 15:55:02 发布
阅读量110 收藏
点赞数
分类专栏： C++ Linux编程 Ubuntu编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_weixiaotao/article/details/108782813
版权
C++ 同时被 3 个专栏收录
43 篇文章 0 订阅
订阅专栏
Ubuntu编程
24 篇文章 0 订阅
订阅专栏
Linux编程
17 篇文章 0 订阅
订阅专栏 
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <signal.h>
#include <errno.h>
#define IPV4(a,b,c,d) ((a<<0)|(b<<8)|(c<<16)|(d<<24))
#define ENDWITH '!' //需要PMAC代替
#define SEPERATE "," //需要PMAC代替
#define TIMER_USER 10000 //10ms
#define STRING_FUN 0
#define NUM_STRNG_FUN 1
#define BYTES_FUN 2     
#define ONLY2TJ 3   //定义四种功能
#define MAX_CLIENT 4
#define MAX_SIZE_ 100
#define PMAC_VAR 10
#define tout_ 2 //接收超时处理时间

extern int close_client[MAX_CLIENT];//需用PMAC代替，自动断开客户端链接;

extern int init_flag,max_index,exmaxfd;

extern char *all_data;
//extern char all_send_data[MAX_SIZE_*MAX_CLIENT];//需用PMAC代替
extern char *all_send_data;

//extern double all_send_num[PMAC_VAR*MAX_CLIENT];//需用PMAC代替
extern double *all_send_num;//需用PMAC代替

extern double *PMAC_global;

extern fd_set all_fds,exread_fds;

extern int all_tcp_client[MAX_CLIENT],FUN_FLAG[MAX_CLIENT];

//extern int all_monitor_addr_port[20]; //用global变量代替 5 * MAX_CLIENT

extern int *all_monitor_addr_port; 

void init_external_client();

int addr_gather(int *five_array,in_addr_t *rec);

void deal_data();

void deal_string(int,int);

void deal_num_string(int,int);

void deal_num_byte(int,int);

void deal_ONLY2TJ(int,int);

void deal_send();

void alarm_tiout();

//处理传来的字符串
void split_cmd(char *src, const char *separator, char **dest, int *num)
{
 /*
 src 源字符串的首地址(buf的地址)
 separator 指定的分割字符
 dest 接收子字符串的数组
 num 分割后子字符串的个数
 */
 char *pNext;
 int count = 0;
 if (src == NULL || strlen(src) == 0) //如果传入的地址为空或长度为0，直接终止
 return;
 if (separator == NULL || strlen(separator) == 0) //如未指定分割的字符串，直接终止
 return;
 pNext = (char *)strtok(src,separator); //使用(char *)进行强制类型转换
 while(pNext != NULL) {
  *dest++ = pNext;
  ++count;
  pNext = (char *)strtok(NULL,separator);  //使用(char *)进行强制类型转换
 }
 *num = count;
}

void recv_tj(char *comd){
 char *split_comd[100];
 int num=0; 
 split_cmd(comd,"!",split_comd,&num);
 double x=0,y=0,z=0,a=0,b=0,c=0;
 int i=0;
 while(i<num){
 sscanf(split_comd[i],"%lf,%lf,%lf,%lf,%lf,%lf",&x,&y,&z,&a,&b,&c);
 SetGlobalArrayVar(tj_data_x,i,x);
 SetGlobalArrayVar(tj_data_y,i,y);
 SetGlobalArrayVar(tj_data_z,i,z);
 SetGlobalArrayVar(tj_data_a,i,a);
 SetGlobalArrayVar(tj_data_b,i,b);
 SetGlobalArrayVar(tj_data_c,i,c);
 i++;
 }
 SetGlobalVar(isfinish,1);
}

#include <gplib.h>   // Global Gp Shared memory pointer
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "client.h"
#include "../../Include/pp_proj.h"

int all_tcp_client[MAX_CLIENT]={-1,-1,-1,-1};

int close_client[MAX_CLIENT] = {-1,-1,-1,-1};//需用PMAC代替，自动断开客户端链接;

int FUN_FLAG[MAX_CLIENT] = {-1,-1,-1,-1};//需用PMAC代替

char temp_data[MAX_SIZE_*MAX_CLIENT];


char buff_data[MAX_SIZE_*MAX_CLIENT];//缓冲区

//char all_data[MAX_SIZE_*MAX_CLIENT];//需用PMAC代替
char *all_data=NULL;
//char all_send_data[MAX_SIZE_*MAX_CLIENT];//需用PMAC代替
char *all_send_data = NULL;

//double all_send_num[PMAC_VAR*MAX_CLIENT]={0};//需用PMAC代替
double *all_send_num = NULL;//需用PMAC代替

//double PMAC_global[PMAC_VAR*MAX_CLIENT];//需用PMAC代替，接受发过来的字符串浮点数;每个最大为PMAC_VAR个
double *PMAC_global = NULL;
struct timeval tv1;//select超时时间

int max_index = 0;

int global_signal[MAX_CLIENT] = {-1,-1,-1,-1};

int exmaxfd = -1;

//int all_monitor_addr_port[MAX_CLIENT*5] = {0};

//int *Pall_monitor_addr_port = all_monitor_addr_port;//需用PMAC代替
int *all_monitor_addr_port = NULL;

fd_set all_fds,exread_fds;

int init_flag = 0;

void init_external_client()  //需要可以建立4
{
    if(init_flag == 0){//初始化一次
        FD_ZERO(&all_fds);
        FD_ZERO(&exread_fds);
        tv1.tv_sec = 0;//select超时时间,0s
        tv1.tv_usec = 0;//select超时时间,0us
        memset(temp_data,0,sizeof temp_data);
        memset(buff_data,0,sizeof buff_data);
        signal(SIGALRM,alarm_tiout);
		all_data=(char*)pushm+200;				//200	
		all_send_data=(char*)pushm+600;				
		all_send_num=(double*)pushm+125;					//1000
		PMAC_global=(double*)pushm+165; //1320
		all_monitor_addr_port=(int*)pushm+410;   //1640
        init_flag = 1;
    }
    if(all_tcp_client[MAX_CLIENT -1] != -1){
		printf("linked reach max\n");
		return;
	}
	int traverse_num = 0;
    int arrindex = 0;
    for(;traverse_num < 5*MAX_CLIENT;traverse_num+=5){
        
		if(all_monitor_addr_port[traverse_num] && all_monitor_addr_port[traverse_num+4]){
			if(all_tcp_client[traverse_num / 5] != -1 && FD_ISSET(all_tcp_client[traverse_num / 5],&all_fds)){//证明该客户端已经链接，重新连接
				close(all_tcp_client[traverse_num / 5]);
                FD_CLR(all_tcp_client[traverse_num / 5],&all_fds);
                if(all_tcp_client[traverse_num / 5]==exmaxfd)exmaxfd--;
                all_tcp_client[traverse_num / 5]=-1;
			}
            struct sockaddr_in external_serv_addr;//局部结构体
            memset(&external_serv_addr,0,sizeof external_serv_addr);//清空结构体
            int external_cfd = socket(AF_INET,SOCK_STREAM,0);
            external_serv_addr.sin_port = htons(all_monitor_addr_port[traverse_num+4]);
            external_serv_addr.sin_family = AF_INET;
            if(!addr_gather(&all_monitor_addr_port[traverse_num],&external_serv_addr.sin_addr.s_addr)){
                perror("addr transfer");
                return;
            }
            int rev = connect(external_cfd,(struct sockaddr *)&external_serv_addr,sizeof external_serv_addr);
            if (rev == -1)
            {
                perror("external_client_connect");
                memset(&all_monitor_addr_port[traverse_num],0,5*sizeof(double));
                memset(&all_send_data[(traverse_num) / 5 * MAX_SIZE_],0, MAX_SIZE_ * sizeof(char));
                memset(&all_send_num[(traverse_num) / 5 * PMAC_VAR],0, PMAC_VAR * sizeof(char));
                return;//如果服务器未启动，连接失败可以进行多次连接
            }
            for(;arrindex < MAX_CLIENT;arrindex++){
               if(all_tcp_client[arrindex] == -1){
                   all_tcp_client[arrindex] = external_cfd;//将套接字加入自定义队列
                   FD_SET(external_cfd,&all_fds);//加入读取队列
                   if(external_cfd>exmaxfd) exmaxfd = external_cfd;
                   max_index = arrindex; //更新最大自定索引
                   break;
               }
            }
            memset(&all_monitor_addr_port[traverse_num],0,5 * sizeof(int));
		}
	}
    return;
}

int addr_gather(int *five_array,in_addr_t *rec)//返回字符串IP
{
	unsigned int value=IPV4(five_array[0],five_array[1],five_array[2],five_array[3]);
	in_addr_t ip;
	memcpy(&ip,&value,sizeof(value));
    return inet_pton(AF_INET,inet_ntoa(*((struct in_addr*)&ip)),rec);
}

void deal_data()
{
    exread_fds=all_fds;
    int sr=select(exmaxfd+1,&exread_fds,NULL,NULL,&tv1);//不阻塞
    if(sr==-1){/*if(errno != EINTR){*/perror("select perror:");return;/*}else{errno = 0;}*/}//防止闹钟线程
    else if(sr==0){tv1.tv_sec = 0;tv1.tv_usec = TIMER_USER;deal_send();set_var();return;}
    int tmpindex = 0;
    for(;tmpindex <= max_index;tmpindex++){
        if (FD_ISSET(all_tcp_client[tmpindex],&exread_fds)){
            int n = recv(all_tcp_client[tmpindex],&temp_data[tmpindex * MAX_SIZE_],MAX_SIZE_ * sizeof(char),0);
            if(n <= 0){
                close(all_tcp_client[tmpindex]);
                FD_CLR(all_tcp_client[tmpindex],&all_fds);
                if(all_tcp_client[tmpindex]==exmaxfd)exmaxfd--;
                all_tcp_client[tmpindex]=-1;
                printf("%dth client host closed\n",tmpindex);
                continue;
            }
            if(FUN_FLAG[tmpindex] == STRING_FUN){
                    deal_string(tmpindex,n);
                }
            if(FUN_FLAG[tmpindex] == NUM_STRNG_FUN){
                    deal_num_string(tmpindex,n);
            }
            if(FUN_FLAG[tmpindex] == BYTES_FUN){
                    deal_num_byte(tmpindex,n);
            }
			if(FUN_FLAG[tmpindex] == ONLY2TJ){
                    deal_ONLY2TJ(tmpindex,n);
            }
        }
    }
}

void deal_string(int tmpindex,int n)
{
    if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH && buff_data[tmpindex * MAX_SIZE_] == '\0'){
        memcpy(&all_data[tmpindex * MAX_SIZE_],&temp_data[tmpindex * MAX_SIZE_],n -1);
        memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
        printf("%dth client %s\n",tmpindex,&all_data[tmpindex * MAX_SIZE_]);
    }else if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH && buff_data[tmpindex * MAX_SIZE_] != '\0'){//是上一包的
        int cindex = 0;
        while(buff_data[tmpindex * MAX_SIZE_+cindex] != '\0'){
            cindex++;
        }
        memcpy(&all_data[tmpindex * MAX_SIZE_],&buff_data[tmpindex * MAX_SIZE_], cindex);
        memcpy(&all_data[tmpindex * MAX_SIZE_ + cindex],&temp_data[tmpindex * MAX_SIZE_],n-1);
        printf("%s\n",&all_data[tmpindex * MAX_SIZE_]);
        memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
        memset(&buff_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));

    }else if(temp_data[tmpindex * MAX_SIZE_ + n] == '\0'){//不够一包
            int cindex = 0;
            while(buff_data[tmpindex * MAX_SIZE_+cindex] != '\0'){
                cindex++;
            }
            if(cindex >= MAX_SIZE_){
                memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                memset(&buff_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                printf("excceed max range\n");
            }
            memcpy(&buff_data[tmpindex * MAX_SIZE_ + cindex],&temp_data[tmpindex * MAX_SIZE_],n);
            memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
            if(global_signal[tmpindex] == -1){
                global_signal[tmpindex] = tmpindex;
                alarm(tout_);
            }
        }else if(temp_data[tmpindex * MAX_SIZE_ + MAX_SIZE_-1] != '\0'){//大于接受范围，丢弃
                    memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                    printf("excceed max range\n");
                }
}

void deal_num_string(int tmpindex, int n)
{
    if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH && buff_data[tmpindex * MAX_SIZE_] == '\0'){
        temp_data[tmpindex * MAX_SIZE_ + n - 1] = '\0';
        char tempdeal[MAX_SIZE_];
        memcpy(tempdeal,&temp_data[tmpindex * MAX_SIZE_],MAX_SIZE_);
        char *p = strtok(tempdeal,SEPERATE);
        int mycount = 0;
        while(p!=NULL){
              PMAC_global[PMAC_VAR*tmpindex+mycount] = atof(p);
              printf("%dth %lf\n",tmpindex,PMAC_global[PMAC_VAR*tmpindex+mycount]);
              p = strtok(NULL,SEPERATE);
              mycount++;
        }
    }else if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH && buff_data[tmpindex * MAX_SIZE_] != '\0'){//是上一包的
        int cindex = 0;
        while(buff_data[tmpindex * MAX_SIZE_+cindex] != '\0'){
            cindex++;
        }
        memcpy(&all_data[tmpindex * MAX_SIZE_],&buff_data[tmpindex * MAX_SIZE_], cindex);
        memcpy(&all_data[tmpindex * MAX_SIZE_ + cindex],&temp_data[tmpindex * MAX_SIZE_],n-1);
        char tempdeal[MAX_SIZE_];
        memcpy(tempdeal,&all_data[tmpindex * MAX_SIZE_],MAX_SIZE_);
        char *p = strtok(tempdeal,SEPERATE);
        int mycount = 0;
        while(p!=NULL){
              PMAC_global[PMAC_VAR*tmpindex+mycount] = atof(p);
              printf("%dth %lf\n",tmpindex,PMAC_global[PMAC_VAR*tmpindex+mycount]);
              p = strtok(NULL,SEPERATE);
              mycount++;
        }
        memset(&all_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
        memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
        memset(&buff_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));

    }else if(temp_data[tmpindex * MAX_SIZE_ + n] == '\0'){//不够一包
            int cindex = 0;
            while(buff_data[tmpindex * MAX_SIZE_+cindex] != '\0'){
                cindex++;
            }
            if(cindex >= MAX_SIZE_){
                memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                memset(&buff_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                printf("excceed max range\n");
            }
            if(global_signal[tmpindex] == -1){
                global_signal[tmpindex] = tmpindex;
                alarm(tout_);
            }
            memcpy(&buff_data[tmpindex * MAX_SIZE_ + cindex],&temp_data[tmpindex * MAX_SIZE_],n);
            memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
        }else if(temp_data[tmpindex * MAX_SIZE_ + MAX_SIZE_-1] != '\0'){//大于接受范围，丢弃
                    memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                    printf("excceed max range\n");
                }
}

void deal_num_byte(int tmpindex, int n)
{
    if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH && buff_data[tmpindex * MAX_SIZE_] == '\0'){
        int i = 0;
        for(;i < (int)((n-1)/(sizeof(double)));i++){
            PMAC_global[PMAC_VAR * tmpindex+i] = *(double *)(&temp_data[tmpindex * MAX_SIZE_]+i*sizeof(double));
        }
        memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_*sizeof(char));
    }else if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH && buff_data[tmpindex * MAX_SIZE_] != '\0'){//是上一包的
        int cindex = 0;
        while(buff_data[tmpindex * MAX_SIZE_+cindex] != '\0'){
            cindex++;
        }
        memcpy(&all_data[tmpindex * MAX_SIZE_],&buff_data[tmpindex * MAX_SIZE_], cindex);
        memcpy(&all_data[tmpindex * MAX_SIZE_ + cindex],&temp_data[tmpindex * MAX_SIZE_],n-1);
        int i = 0;
        for(;i < (int)((n-1)/(sizeof(double)));i++){
            PMAC_global[PMAC_VAR * tmpindex+i] = *(double *)(&temp_data[tmpindex * MAX_SIZE_]+i*sizeof(double));
        }
        memset(&all_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
        memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
        memset(&buff_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));

    }else if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == '\0'){//不够一包
            int cindex = 0;
            while(buff_data[tmpindex * MAX_SIZE_+cindex] != '\0'){
                cindex++;
            }
            if(cindex >= MAX_SIZE_){
                memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                memset(&buff_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                printf("excceed max range\n");
            }
            if(global_signal[tmpindex] == -1){
                global_signal[tmpindex] = tmpindex;
                alarm(tout_);
            }
            memcpy(&buff_data[tmpindex * MAX_SIZE_ + cindex],&temp_data[tmpindex * MAX_SIZE_],n);
            memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
        }else if(temp_data[tmpindex * MAX_SIZE_ + MAX_SIZE_-1] != '\0'){//大于接受范围，丢弃
                    memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                    printf("excceed max range\n");
                }
}

void deal_ONLY2TJ(int tmpindex, int n)
{
	if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH)
	{
		temp_data[tmpindex * MAX_SIZE_ + n - 1] = '\0';
        char tempdeal[MAX_SIZE_];
        memcpy(tempdeal,&temp_data[tmpindex * MAX_SIZE_],MAX_SIZE_);
		//处理收到的字符串，放入全局变量中
		recv_tj(tempdeal);
	}
}

void deal_send()
{

    int n = 0;
    for(;n<=max_index;n++){
        if(close_client[n] == 1 && FD_ISSET(all_tcp_client[n],&all_fds))
        {
            close(all_tcp_client[n]);
            FD_CLR(all_tcp_client[n],&all_fds);
            if(all_tcp_client[n]==exmaxfd)exmaxfd--;
            all_tcp_client[n]=-1;
			SetGlobalArrayVar(c_client,n,-1);
            printf("%dth client voluntarily closed\n",n);
            continue;
        }
        if(FD_ISSET(all_tcp_client[n],&all_fds)){
            if(FUN_FLAG[n] == STRING_FUN || FUN_FLAG[n] == ONLY2TJ){
                if(all_send_data[n * MAX_SIZE_] == '\0'){
                    continue;
                }
                char will_send[100];
                memset(will_send,0,sizeof will_send);
                int tmpcount = 0;
                while(all_send_data[n * MAX_SIZE_ + tmpcount] != ENDWITH){
                    will_send[tmpcount] =  all_send_data[n * MAX_SIZE_ + tmpcount];
                    tmpcount++;
                }
                send(all_tcp_client[n],will_send,tmpcount,0);
                memset(&all_send_data[n * MAX_SIZE_],0,MAX_SIZE_);
            }else if(FUN_FLAG[n] == NUM_STRNG_FUN){
                if(all_send_num[n * PMAC_VAR] == 0){
                    continue;
                }
                char will_send[100];
                memset(will_send,0,sizeof will_send);
                int tmpcount = 0;
                while(all_send_num[n * PMAC_VAR + tmpcount] != 0){
                    char tmpbuf[12];
                    memset(tmpbuf,0,sizeof tmpbuf);
                    gcvt(all_send_num[n * PMAC_VAR + tmpcount],8,tmpbuf);
                    strcat(tmpbuf,SEPERATE);
                    strcat(will_send,tmpbuf);
                    tmpcount++;
                }
                will_send[strlen(will_send)-1] = ENDWITH;
                send(all_tcp_client[n],will_send,strlen(will_send),0);
                memset(&all_send_num[n * PMAC_VAR],0,PMAC_VAR*sizeof(double));
            }else if(FUN_FLAG[n] == BYTES_FUN){
                if(all_send_num[n * PMAC_VAR] == 0){
                    continue;
                }
                char will_send[100];
                memset(will_send,0,sizeof will_send);
                int tmpcount = 0;
                while(all_send_num[n * PMAC_VAR + tmpcount] != 0){
                    tmpcount++;
                }
                memcpy(will_send,&all_send_num[n * PMAC_VAR],tmpcount*sizeof(double));
                will_send[tmpcount*sizeof(double)] = ENDWITH;
                send(all_tcp_client[n],will_send,tmpcount*sizeof(double)+1,0);
                memset(&all_send_num[n * PMAC_VAR],0,PMAC_VAR*sizeof(double));
            }

        }
    }
}

void alarm_tiout()//接收数据延时错误处理
{
    int n = 0;
    for (;n<MAX_CLIENT;n++){
        if(global_signal[n] != -1){
            if(buff_data[global_signal[n] * MAX_SIZE_] != '\0'){
                memset(&buff_data[global_signal[n] * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                memset(&all_data[global_signal[n] * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                global_signal[n] = -1;
            }
        }
    }
}

void set_var()
{
	double var_temp[4];
	int i;
	for(i=0;i<4;i++)
	{
		var_temp[i]=GetGlobalArrayVar(c_client,i);
		close_client[i]=(int)var_temp[i];
	}
	
	
	double fun_temp[4];
	for(i=0;i<4;i++)
	{
		fun_temp[i]=GetGlobalArrayVar(fun_flag,i);
		FUN_FLAG[i]=(int)fun_temp[i];
	}
}



int main(void)
{	
	InitLibrary();
	while(1)
	{
		init_external_client();
		deal_data();
	}
	CloseLibrary();	
	return 0;
}
wxtao__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux客户端连接工具
11-08
linux客户端连接工具，破解版MobaXterm，免安装，可以直接用
cmake学习（二）引用外部库（find_package分析）
qq_38170211的博客
04-22 1408
案例：lio-sam-linux项目的CMakeLists.txt 通过这个例子学习一下引用外部库的相关内容。 （貌似项目本身的构建结构不太符合规范，这个后面再修改。，。） 项目路径： CMakeLists.txt cmake_minimum_required(VERSION 2.8.3) project(lio_sam_linux) #set命令可以设置普通变量、缓存条目、环境变量三种变量的值。 set(CMAKE_BUILD_TYPE "Release") set(CMAKE_CXX_FLAGS "
C指针原理（39）-GLIB
The research on computer technolog
04-20 559
一、简述与配置 GLib是一个跨平台的、用C语言编写的库，起初是GTK+的一部分，但到了GTK+第二版，开发者决定把跟图形界面无关的代码分开，这些代码于是就组装成了GLib。因为GLib具有跨平台特性，所以用它编写的程序可以无需进行大幅度修改就可以在其他程序上编译和运行。 glib库是Linux平台下最常用的C语言函数库，它具有很好的可移植性和实用性。 glib是Gtk +库和Gnome的基础。g...
glib的头文件glib.h介绍
yazhiye的专栏
03-22 9649
glib库是Linux平台下最常用的C语言函数库，它具有很好的可移植性和实用性。 glib是Gtk +库和Gnome的基础。glib可以在多个平台下使用，比如Linux、Unix、Windows等。glib为许多标准的、常用的C语言结构提供了相应的替代物。 使用glib库的程序都应该包含glib的头文件glib.h。 ########################### g
Linux学习之客户端软件介绍
haiyangyiba的专栏
03-01 3836
http://www.chendd.cn/information/viewInformation/experienceShare/284.a 本篇文章所述的客户端软件指使用Xshell连接远程Linux虚拟机，使用Xftp作为文件传输传输工具，至于其它的同款类似软件想了解得需要自行百科了。经过别人的介绍和这几天的使用发现这款软件用起来体验还是不错的，首先界面是中文的，需要什么cao作点一点，看一...
Linux cmp命令用法详解
01-09
cmp [-clsv][-i ][--help][第一个文件][第二个文件] 参数： -c或–print-chars 除了标明差异处的十进制字码之外，一并显示该字符所对应字符。 -i或–ignore-initial= 指定一个数目。 -l或–verbose 标示出所有不一样...
cmp_linuxc_
09-29
基于Linux系统的触摸屏识别手指触摸的坐标判断
CMP操作系统技术.doc
06-03
CMP操作系统技术.doc
LINUX操作系统（电子教案，参考答案）
07-11
Linux是一个多任务、多用户的操作系统，它以其良好的特性和资源的免费性而得到了蓬勃的发展。 　本书通过大量的图示和实例，深入浅出的介绍了Linux的基本原理和应用。主要包括Linux的基本概念和操作，Linux的树型...
CMP.rar_cmp_it
09-14
you can use it to get the avi the cmp picture
使用客户端工具SecureCRT连接linux
m0_37773187的博客
06-27 5459
SecureCRT是一款支持SSH（SSH1和SSH2）的终端仿真程序，简单地说是Windows下登录UNIX或Linux服务器主机的软件。1.下载客户端工具包SecureCRT2.打开SecureCRT.exe3.在linux上输入ifconfig查找ip   4.输入ip  5.输入用户名和密码，连接到linux上6.解决编码问题(可以在linux目录/etc/sysconfig下输入cat ...
linux 命令客户端,linux 网络客户端命令
weixin_29143935的博客
05-14 173
1、 elinks-dump 以文本的方式显示eg:elinks -dump http://www.google.cn-source 以源码的方式显示eg:elinks -source http://www.google.cn2、wget 下载--tries=10 尝试下载几次-o 把连接保存在一个文件里面-r 打开递归模式axel 类似迅雷，支持多线程3、ssh ：sec...
linux客户端工具有哪些,Linux命令以及客户端工具的使用
weixin_42525289的博客
05-03 1097
一.终端工具：SecureCRT-v6.58HSecureCRT是一款支持SSH(SSH1和SSH2)的终端仿真程序，同时支持Telnet和rlogin 协议。SecureCRT是一款用于连接运行包括Windows、UNIX和VMS的远程系统的理想工具。通过使用内含的VCP命令行程序可以进行加密文件的传输。有流行CRTTelnet客户机的所有特点,包括:自动注册、对不同主机保持不同的特性、打印功能...
linux中nmcli命令的使用及网络配置
weixin_34267123的博客
09-07 3489
Red Hat Enterprise Linux 7 与 CentOS 7 中默认的网络服务由 NetworkManager 提供，这是动态控制及配置网络的守护进程，它用于保持当前网络设备及连接处于工作状态，同时也支持传统的 ifcfg 类型的配置文件。NetworkManager 可以用于以下类型的连接：Ethernet，VLANS，Bridges，Bonds，Tea...
linux客户端工具
juzhenxing的博客
05-30 2311
FinalShell 下载地址
int可以表示的最大整数为多少？
看看世界看看你
01-03 6329
int是有符号整数，可以表示的最大整数为： 二进制表示方法： 0111 1111 1111 1111 1111 1111 1111 1111 那么他的大小为多少呢？ (2^31 -1) 这个是怎么算的呢？ 其实就是正常的算法： 1* 2 ^ 0 + 1* 2 ^ 1 +....+1 * 2 ^ 30 那么这个其实是一个等比数列： 公比为2，首项为1，尾项为2 ^ 30。 代入公式可得： (1- 2 ^ 30 * 2)/-1 = 2 ^ 31 -1 ...
C语言实现16进制转为10进制
看看世界看看你
09-10 6045
#include <stdio.h> #include <string.h> #include <math.h> void conver(char arr[]) { int i, j = 0, k = 0, sum = 0, n = strlen(arr); int num[100]; for (i = 0; i < n; i++) { switch (arr[i]) { case 'A':num[j++] = 10; break; c
C++中multimap函数equal_range的用法
看看世界看看你
07-07 5814
首先，我们要清楚map 和 multimap都底层都是红黑树，其数据插入进去的时候就已经是有序的了。multimap可以插入相同的键，因此就存在一个问题，我们如何知道插入了多少个相同的元素呢？那么，下面的函数就派上用场了。 equal_range()函数主要是求在multimap中有多少个重复的数。 比如：可以看出该函数返回值是两个迭Map类型的迭代器，分别指向该元素的起始位置和该元素结束位置的下一个元素的位置。 #include <iostream> #include <map>
linux命令cmp
最新发布
08-24
若发现有所差异，预设会标示出第一个不同之处的字符和列数编号。可以通过cmp命令来检查两个文件是否内容一致。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值