[关闭]
@huyl08 2016-09-13T12:06:32.000000Z 字数 6060 阅读 1470

星迹迷航新手上路（C/C++版）

C/C++ 星迹迷航 文件读写

  1. 完整的C/C++示例源码可通过该链接下载
  2. 推荐使用Visual Studio或者CLion作为集成开发环境。

C/C++处理数据

以下为C/C++源码样例

坐标辅助类

头文件coordinate.h

  1. #include <string.h>
  2. #include <stdlib.h>
  4. #ifndef STARTREK_COORDINATE_H
  5. #define STARTREK_COORDINATE_H
  7. // 声明坐标结构体
  8. struct _coordinate{
  9.     // 经度
  10.     double x;
  11.     // 纬度
  12.     double y;
  13. };
  15. // 声明坐标结构体指针
  16. typedef struct _coordinate* coordinate;
  18. // 声明坐标序列结构体
  19. struct _coordinate_sequence{
  20.     // 坐标序列头指针
  21.     coordinate* sequence;
  22.     // 坐标序列当前大小
  23.     int sequence_size;
  24.     // 坐标序列容量大小
  25.     int sequence_capacity;
  26. };
  28. // 声明坐标序列结构体指针
  29. typedef struct _coordinate_sequence* coordinate_sequence;
  31. // 将输入字符串input_string按分隔符delim拆分，解析为一个坐标序列返回
  32. coordinate_sequence geometry_parse(char* input_string, char* delim);
  34. // 将输入字符串转化为一个坐标
  35. coordinate point_parse(char* input_string);
  37. // 调整坐标序列的容量，以2为倍数放大坐标序列容量
  38. coordinate_sequence resize_coordinates(coordinate_sequence origin);
  40. #endif //STARTREK_COORDINATE_H

源文件coordinate.c

  1. #include "coordinate.h"
  3. coordinate_sequence geometry_parse(char* input_string, char* delim){
  4.     // 使用malloc方法分配内存空间
  5.     coordinate_sequence result = (coordinate_sequence) malloc ( sizeof( struct _coordinate_sequence ) );
  6.     // 初始化当前坐标序列的容量、大小和坐标头指针
  7.     result->sequence_capacity = 4;
  8.     result->sequence_size = 0;
  9.     result->sequence = (coordinate*) malloc ( result->sequence_capacity * sizeof(struct _coordinate) );
  10.     // 将坐标指针指向的空间快速初始化
  11.     memset(result->sequence, 0, result->sequence_capacity * sizeof( struct _coordinate) );
  13.     // 初始化字符串分割的上下文变量
  14.     int context_size = 4096;
  15.     char** context = (char**) malloc ( context_size * sizeof( char* ) );
  16.     // 使用strtok_r分割输入字符串
  17.     char* buffer = strtok_r(input_string, delim, context);
  18.     // 当分割有效时，重复解析过程
  19.     while( buffer != NULL ){
  20.         // 将当前字符串解析为坐标
  21.         coordinate intermediate = point_parse(buffer);
  22.         // 坐标序列的复制和大小增加
  23.         result->sequence[result->sequence_size] = intermediate;
  24.         result->sequence_size++;
  26.         // 坐标序列大小达到容量，则进行扩容
  27.         if( result->sequence_size == result->sequence_capacity )
  28.             result = resize_coordinates(result);
  30.         // 继续拆分当前序列
  31.         buffer = strtok_r(NULL, delim, context);
  32.     }
  33.     return result;
  34. }
  36. coordinate point_parse(char* input_string){
  37.     coordinate result = (coordinate) malloc ( sizeof( struct _coordinate ) );
  39.     int context_size = 24;
  40.     char** context = (char**) malloc ( context_size * sizeof( char* ) );
  41.     // 使用":"分割输入字符串input_string为两个变量，并分别用atof方法将字符串数组转化为浮点数
  42.     char* buffer = strtok_r(input_string, ":", context);
  43.     result->x = atof(buffer);
  45.     buffer = strtok_r(NULL, ":", context);
  46.     result->y = atof(buffer);
  48.     return result;
  49. }
  51. coordinate_sequence resize_coordinates(coordinate_sequence origin){
  52.     // 初始化新坐标序列的内存
  53.     coordinate_sequence target = (coordinate_sequence) malloc( sizeof( struct _coordinate_sequence) );
  54.     // 新坐标序列按2倍扩容
  55.     target->sequence_capacity = 2 * origin->sequence_capacity;
  56.     target->sequence_size = origin->sequence_size;
  57.     target->sequence = (coordinate*) malloc( target->sequence_capacity * sizeof( struct _coordinate) );
  58.     // 快速初始化新坐标序列的内存
  59.     memset( target->sequence, 0, target->sequence_capacity * sizeof( struct _coordinate ) );
  61.     // 将原有的坐标拷贝到新坐标序列中
  62.     for( int i = 0 ; i < target->sequence_size; i++ )
  63.         target->sequence[i] = origin->sequence[i];
  65.     // 释放旧坐标序列的指针
  66.     free(origin);
  67.     origin = NULL;
  69.     return target;
  70. }

读取电子地图文件

头文件link.h

  1. #include "coordinate.h"
  2. #include <stdio.h>
  4. #ifndef STARTREK_LINK_H
  5. #define STARTREK_LINK_H
  7. // 声明路段结构体
  8. struct _link{
  9.     // 路段编号
  10.     int link_id;
  11.     // 起始点编号
  12.     int from_node;
  13.     // 终止点编号
  14.     int to_node;
  15.     // 道路等级
  16.     int link_class;
  17.     // 道路长度
  18.     double link_length;
  19.     // 道路坐标序列
  20.     coordinate_sequence coordinates;
  21. };
  23. // 声明路段结构体指针
  24. typedef struct _link* link;
  26. // 声明路段序列结构体
  27. struct _link_sequence{
  28.     int sequence_size;
  29.     int sequence_capacity;
  30.     link* sequence;
  31. };
  33. // 声明路段序列结构体指针
  34. typedef struct _link_sequence* link_sequence;
  36. // 根据输入位置link_file读入文件
  37. link_sequence read_link(char* link_file);
  39. // 调整路段序列容量
  40. link_sequence resize_links(link_sequence origin);
  42. #endif //STARTREK_LINK_H

源文件link.c

  1. #include "link.h"
  3. link_sequence read_link(char* link_file){
  4.     // 分配路段序列内存
  5.     link_sequence result = (link_sequence) malloc ( sizeof( struct _link_sequence) );
  6.     // 初始化路段序列的容量、大小和路段头指针
  7.     result->sequence_capacity = 10;
  8.     result->sequence_size = 0;
  9.     result->sequence = (link*) malloc ( result->sequence_capacity * sizeof(link) );
  10.     // 快速初始化路段序列
  11.     memset( result->sequence, 0, result->sequence_capacity * sizeof(link));
  13.     // 打开文件指针
  14.     FILE* file = fopen(link_file, "r");
  15.     // 文件不存在，返回空指针
  16.     if( file == NULL ){
  17.         printf("Faile to open file \"%s\"", link_file);
  18.         return NULL;
  19.     }
  21.     // 声明文件输入缓存变量
  22.     int buffer_size = 4096;
  23.     char* buffer = (char*) malloc ( buffer_size * sizeof(char) );
  24.     char* gets_return = fgets(buffer, buffer_size, file);
  25.     // 按行读取数据
  26.     while( gets_return != NULL ){
  27.         // 按","拆分当前行
  28.         char* token = strtok(buffer, ",");
  29.         // 生成路段结构体指针
  30.         link link_new = (link) malloc ( sizeof(struct _link) );
  31.         // 解析路段信息
  32.         link_new->link_id = atoi(token);
  33.         token = strtok(NULL, ",");
  34.         link_new->from_node = atoi(token);
  35.         token = strtok(NULL, ",");
  36.         link_new->to_node = atoi(token);
  37.         token = strtok(NULL, ",");
  38.         link_new->link_length = atof(token);
  39.         token = strtok(NULL, ",");
  40.         link_new->link_class = atoi(token);
  41.         token = strtok(NULL, ",");
  42.         link_new->coordinates = geometry_parse(token, ";");
  43.         // 将新路段赋值给路段序列，路段序列大小增加
  44.         result->sequence[result->sequence_size] = link_new;
  45.         result->sequence_size++;
  46.         // 路段序列大小达到容量，进行扩容
  47.         if( result->sequence_size == result->sequence_capacity )
  48.             result = resize_links(result);
  49.         // 读取新的一行
  50.         gets_return = fgets(buffer, buffer_size, file);
  51.     }
  52.     // 关闭文件指针
  53.     fclose(file);
  54.     file = NULL;
  55.     return result;
  56. }
  59. link_sequence resize_links(link_sequence origin){
  60.     // 初始化新的路段序列指针内存
  61.     link_sequence target = (link_sequence) malloc ( sizeof( struct _link_sequence) );
  62.     // 初始化新的路段序列的容量、大小和头指针，容量按2倍比例扩容
  63.     target->sequence_capacity = 2 * origin->sequence_capacity;
  64.     target->sequence_size = origin->sequence_size;
  65.     target->sequence = (link*) malloc ( target->sequence_capacity * sizeof( struct _link) );
  66.     // 快速初始化头指针内存空间
  67.     memset(target->sequence, 0, target->sequence_capacity * sizeof( struct _link));
  69.     // 原有路段赋值给新的路段序列
  70.     for( int i = 0 ; i < target->sequence_size; i++ )
  71.         target->sequence[i] = origin->sequence[i];
  73.     // 释放旧的路段序列指针
  74.     free(origin);
  75.     origin = NULL;
  77.     return target;
  78. }

测试主类

头文件main.h

  1. #include "link.h"
  2. #include <stdio.h>
  4. #ifndef STARTREK_MAIN_H
  5. #define STARTREK_MAIN_H
  7. int main();
  9. #endif //STARTREK_MAIN_H

源文件main.c

  1. #include "main.h"
  3. int main() { 
  4.     // 读入路段序列
  5.     link_sequence star_trek = read_link("gis.txt"); 
  6.     return 0;
  7. }

附录A 电子地图数据样例

  1. 1,3,4,280.3,2,115.488988:39.917917;115.488997:39.917938;115.489045:39.918061;115.489219:39.918316;115.489335:39.918486;115.489366:39.918540;115.489382:39.918612;115.489385:39.918672;115.489373:39.918713
  2. 3,7,8,173.2,2,115.381547:39.950776;115.381786:39.950461;115.381848:39.950355;115.381887:39.950260;115.381913:39.950163

附录B 浮动车数据样例

  1. 57952495354,20160701120100,116.372966,39.908912,26.00,262
  2. 13381083463,20160701120147,116.387472,39.889589,26.00,266
  3. 13311492120,20160701120144,116.355589,39.993436,10.00,260
  4. 13439610594,20160701120147,116.394988,39.940625,0.00,0
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注