c 实现IO流

//
//  fs_stream.h
//  fsnet
//
//  Created by Vincent on 14-5-22.
//  Copyright (c) 2014年 Vincent. All rights reserved.
//

#ifndef fsnet_fs_stream_h
#define fsnet_fs_stream_h

#include "fs_define.h"

#define OUTPUT_STRAEM_DEFAULT_MAX 128

struct fs_stream;
struct fs_input_stream;
struct fs_output_stream;

struct fs_output_stream* fs_create_output_stream(size_t len);
#define fs_create_output_stream_ext fs_create_output_stream(OUTPUT_STRAEM_DEFAULT_MAX)
void fs_stream_free_output( struct fs_output_stream* );
void fs_stream_write_byte( struct fs_output_stream*,  BYTE);
void fs_stream_write_uint32( struct fs_output_stream*,  uint32_t);
void fs_stream_write_uint16( struct fs_output_stream*,  uint16_t);
void fs_stream_write_int32( struct fs_output_stream*,  int32_t);
void fs_stream_write_int16( struct fs_output_stream*,  int16_t);
void fs_stream_write_float( struct fs_output_stream*,  float );
void fs_stream_write_double( struct fs_output_stream*,  double );
void fs_stream_write_data( struct fs_output_stream*,  BYTE*, size_t len );
const BYTE* fs_stream_get_dataptr( struct fs_output_stream* );
size_t fs_stream_get_len( struct fs_output_stream* );
size_t fs_stream_output_sub( struct fs_output_stream*, size_t start, size_t len );

struct fs_input_stream* fs_create_input_stream(const BYTE* data, size_t len);
struct fs_input_stream* fs_create_input_stream_with_copy(const BYTE* data, size_t len);

void fs_input_stream_set_data( struct fs_input_stream*, const BYTE* data, size_t len);
void fs_input_stream_set_data_copy( struct fs_input_stream*, const BYTE* data, size_t len);
size_t fs_input_stream_get_len( struct fs_input_stream* stream);
void fs_input_stream_set_order( struct fs_input_stream*,  BYTE order);
void fs_stream_free_input( struct fs_input_stream* );
BYTE fs_stream_read_byte( struct fs_input_stream* );
uint32_t fs_stream_read_uint32( struct fs_input_stream* );
uint16_t fs_stream_read_uint16( struct fs_input_stream* );
int32_t fs_stream_read_int32( struct fs_input_stream* );
int16_t fs_stream_read_int16( struct fs_input_stream* );
float fs_stream_read_float( struct fs_input_stream* );
double fs_stream_read_double( struct fs_input_stream* );
size_t fs_stream_read_string( struct fs_input_stream* , char**);

void         fs_output_stream_set_script_id( struct fs_output_stream* , fs_script_id _id );
fs_script_id fs_output_stream_get_script_id( struct fs_output_stream* );
void         fs_input_stream_set_script_id( struct fs_input_stream* , fs_script_id _id );
fs_script_id fs_input_stream_get_script_id( struct fs_input_stream* );

#endif
//
//  fs_stream.c
//  fsnet
//
//  Created by Vincent on 14-5-22.
//  Copyright (c) 2014年 Vincent. All rights reserved.
//

#include <stdio.h>
#include <string.h>
#include "fs_define.h"
#include "fs_stream.h"
#include "fs_malloc.h"

#define BASE_STREAM    BYTE byte_order;        BYTE* data; 

struct fs_input_stream{
    BASE_STREAM
    size_t pos;
    size_t len;
    fs_bool copy;
    fs_script_id script_id;
};
struct fs_output_stream{
    BASE_STREAM
    size_t pos;
    size_t buff_len;
    fs_script_id script_id;
};

struct fs_output_stream*
fs_create_output_stream(size_t len){

    struct fs_output_stream* ret = (struct fs_output_stream*)fs_malloc(sizeof(*ret));
    fs_zero(ret, sizeof(*ret));
    ret->data = (BYTE*)fs_malloc(len);
    ret->pos = 0;
    ret->buff_len = len;

    return ret;
}

void
fs_stream_free_output( struct fs_output_stream* stream){

    fs_free(stream->data);
    fs_free(stream);

}

void
fs_stream_write_byte( struct fs_output_stream* stream,  BYTE v){
    fs_stream_write_data(stream, (BYTE*)&v, sizeof(BYTE));
}

void
fs_stream_write_uint32( struct fs_output_stream* stream,  uint32_t v){
    fs_stream_write_data(stream, (BYTE*)&v, sizeof(uint32_t));
}

void
fs_stream_write_uint16( struct fs_output_stream* stream,  uint16_t v){
    fs_stream_write_data(stream, (BYTE*)&v, sizeof(uint16_t));
}

void
fs_stream_write_int32( struct fs_output_stream* stream,  int32_t v){
    fs_stream_write_data(stream, (BYTE*)&v, sizeof(int32_t));
}

void
fs_stream_write_int16( struct fs_output_stream* stream,  int16_t v){
    fs_stream_write_data(stream, (BYTE*)&v, sizeof(int16_t));
}

void
fs_stream_write_float( struct fs_output_stream* stream,  float v){
    fs_stream_write_data(stream, (BYTE*)&v, sizeof(float));
}

void
fs_stream_write_double( struct fs_output_stream* stream,  double v){
    fs_stream_write_data(stream, (BYTE*)&v, sizeof(double));
}

void
fs_stream_write_data( struct fs_output_stream* stream,  BYTE* data, size_t len ){

    while(stream->pos + len > stream->buff_len){
        void* data = fs_realloc(stream->data, stream->buff_len << 1);
        stream->data = data;
        stream->buff_len = stream->buff_len << 1;
    }

    memcpy(stream->data + stream->pos, data, len);
    stream->pos += len;

}

const BYTE*
fs_stream_get_dataptr( struct fs_output_stream* stream){
    return stream->data;
}

size_t fs_stream_get_len( struct fs_output_stream* stream){
    return stream->pos;
}

size_t
fs_stream_output_sub( struct fs_output_stream* stream, size_t start, size_t len ){
    memcpy(stream->data, stream->data + start, len);
    stream->pos = len;
    return len;
}

struct fs_input_stream*
fs_create_input_stream(const BYTE* data, size_t len){

    struct fs_input_stream* ret = (struct fs_input_stream*)fs_malloc(sizeof(*ret));
    fs_zero(ret, sizeof(*ret));
    fs_input_stream_set_data(ret, data, len);
    return ret;

}

struct fs_input_stream*
fs_create_input_stream_with_copy(const BYTE* data, size_t len){

    struct fs_input_stream* ret = (struct fs_input_stream*)fs_malloc(sizeof(*ret));
    fs_zero(ret, sizeof(*ret));
    fs_input_stream_set_data_copy(ret, data, len);
    return ret;
}

void
fs_input_stream_set_data( struct fs_input_stream*  stream, const BYTE* data, size_t len){
    if(stream->data){
        if(stream->copy){
            fs_free(stream->data);
        }
    }
    stream->data = (BYTE*)data;
    stream->pos = 0;
    stream->len = len;
    stream->copy = fs_false;
}

void
fs_input_stream_set_data_copy( struct fs_input_stream* stream, const BYTE* data, size_t len){
    if(stream->data){
        if(stream->copy){
            fs_free(stream->data);
        }
    }

    stream->data = (BYTE*)fs_malloc(len);
    stream->pos = 0;
    stream->len = len;
    stream->copy = fs_true;
    memcpy(stream->data, data, len);
}

size_t
fs_input_stream_get_len( struct fs_input_stream* stream){
    return stream->len;
}

void
fs_input_stream_set_order( struct fs_input_stream* stream,  BYTE order){
    stream->byte_order = order;
}

void
fs_stream_free_input( struct fs_input_stream* stream){
    if(stream->copy){
        fs_free(stream->data);
    }
    fs_free(stream);
}

#define _stream_read(TYPE)TYPE v = 0; memcpy(&v, stream->data + stream->pos, sizeof(v));  stream->pos += sizeof(v); return v;

BYTE fs_stream_read_byte( struct fs_input_stream* stream){
    _stream_read(BYTE);
}
uint32_t fs_stream_read_uint32( struct fs_input_stream* stream){
    _stream_read(uint32_t);
}
uint16_t fs_stream_read_uint16( struct fs_input_stream* stream){
    _stream_read(uint16_t);
}
int32_t fs_stream_read_int32( struct fs_input_stream* stream){
    _stream_read(int32_t);
}
int16_t fs_stream_read_int16( struct fs_input_stream* stream){
    _stream_read(int16_t);
}
float fs_stream_read_float( struct fs_input_stream* stream){
    _stream_read(float);
}
double fs_stream_read_double( struct fs_input_stream* stream){
    _stream_read(double);
}
size_t fs_stream_read_string( struct fs_input_stream* stream, char** out){
    return 0;
}

void
fs_output_stream_set_script_id( struct fs_output_stream* stream, fs_script_id _id ){
    stream->script_id = _id;
}

fs_script_id
fs_output_stream_get_script_id( struct fs_output_stream* stream){
    return stream->script_id;
}

void
fs_input_stream_set_script_id( struct fs_input_stream* stream, fs_script_id _id ){
    stream->script_id = _id;
}

fs_script_id
fs_input_stream_get_script_id( struct fs_input_stream* stream){
    return stream->script_id;
}

c 实现IO流

时间: 2024-10-18 15:12:04

c 实现IO流的相关文章

Java中的IO流

Java中的IO流是实现输入/输出的基础. 按照流的方向不同:分为输入流和输出流. 按照处理数据单位的不同:分为字节流(8位)和字符流(16位). 按照功能不同:分为节点流和处理流 所有面向字节的流类都继承于InputStream类(输入流) 或OutputStream类(输出流),这两个类是抽象类,我们可以利用它的子类来完成不同的功能. InputStream.OutputStream都是抽象类 InputStream抽象了应用程序读取数据的方式 OutputStream抽象类应用程序写出数据

Java IO流 探险

Java的IO流使用了一种装饰器设计模式,它将IO流分为底层节点流和上层处理流.本篇重点在如何访问文件与目录.如何以二进制格式和文本格式来读写数据.对象序列化机制.还有Java7的"NIO.2". 装饰设计模式:当想要对已有的对象进行功能增强时,可以定义类,将已有对象传入,基于已有的功能,并提供加强功能.那么自定义的该类称为装饰类. 装饰类通常会通过构造方法接收被装饰的对象.并基于被装饰的对象的功能,提供更强的功能. IO的方式通常分为:BIO(同步阻塞).NIO(同步非阻塞).AIO

Java 之IO流及应用

IO流 IO流概述及FileWriter类的使用 FileReader类使用 缓冲流介绍和使用 IO流相关案例 NO.one IO流概述及FileWriter类使用 1.1 IO流概述及分类 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的类都在IO包中 流按流向分为两种:输入流,输出流 1.2 FileWriter类使用 A:打开帮助文档 B:点击显示,找到索引,看到输入框 C:你要学习什么内容,你就在框框里面输入什么内容 举例:Random D:看包

IO流和File

读键盘数据.显示数据6-1)io流的分类 按方向:输入流(读取数据) 输出流(写入数据) 按数据类型:字节流(基本数据类型)输出输入 字符流(字节流的包装 对字节流进行处理)输出输入四个核心类: InputStream 字节输入流 OutStream 字节输出流 Reader 字符输入流 Writer 字符输出流6-2) 文件类 File d:/lxj/xx.txt 绝对路径 构造方法: File(String dir,String fileName) File(String path)//pa

Java笔记(19):IO流(01)

1.try...catch的方式处理异常1 1 package cn.itcast_02; 2 3 /* 4 * 异常:程序出现了不正常的情况. 5 * 6 * 程序的异常:Throwable 7 * 严重问题:Error 我们不处理.这种问题一般都是很严重的,比如说内存溢出. 8 * 问题:Exception 9 * 编译期问题:不是RuntimeException的异常 必须进行处理的,因为你不处理,编译就不能通过. 10 * 运行期问题:RuntimeException 这种问题我们也不处

java基础8(io流3)

1.LineNumberReader: public int getLineNumber():获取行号 public void setLineNumber(int lineNumber):设置起始行号 String readLine():读取一行 2.操作基本数据类型的流 DataInputStream:读数据 DataOutputStream:写数据 作用:可以操作基本类型的流对象,其读写顺序必须一致,否则数据有问题. public static void main(String[] args

java IO流

* IO流用来处理设备之间的数据传输 * Java对数据的操作是通过流的方式 * Java用于操作流的类都在IO包中 * 流按流向分为两种:输入流,输出流. * 流按操作类型分为两种: * 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的 * 字符流 : 字符流只能操作纯字符数据,比较方便. * IO流常用父类 * 字节流的抽象父类: * InputStream * OutputStream * 字符流的抽象父类: * Reader * Writer * IO程序

Java:IO流与文件基础

Java:IO流与文件基础 说明: 本文所有内容包含图片均为MrSaber自己编写,转载请练习我哦. 本章内容将会持续更新,大家可以关注一下并给我提供建议,谢谢啦. 走进流 什么是流 流:从源到目的地的字节的有序序列. 在Java中,可以从其中读取一个字节序列的对象称作 输入流,可以向其中写入一个字节序列的对象称作 输出流. ? 这些字节序列的来源可以是:文件.网络连接.内存块等. ? 抽象类InputStream和OutputStream是构成输入/输出(I/O)的基础. ? 因为面向字节的流

5. IO流:★★★★★

IO流:★★★★★,用于处理设备上数据. 流:可以理解数据的流动,就是一个数据流.IO流最终要以对象来体现,对象都存在IO包中. 流也进行分类: 1:输入流(读)和输出流(写). 2:因为处理的数据不同,分为字节流和字符流. 字节流:处理字节数据的流对象.设备上的数据无论是图片或者dvd,文字,它们都以二进制存储的.二进制的最终都是以一个8位为数据单元进行体现,所以计算机中的最小数据单元就是字节.意味着,字节流可以处理设备上的所有数据,所以字节流一样可以处理字符数据. 那么为什么要有字符流呢?因

理解IO流:InputStream和OutputStream,FileInputStream和FileOutputStream,Reader和Writer,FileReader和FileWriter,BufferedInputStream 和 BufferedOutputStream, BufferedReader 和 BufferedWriter,转换流

/* * 1.理解 "流" ? * 动态性.连续性.方向性. * * 2.在java语言中,将数据的输入/输出称之为 IO流. IO流的分类: * 1) 从方向分: 输入流 , 输出流. (参照计算机的内存) * 将数据送到内存中去称之为输入流.反之,称之为输出流. * * 2) 从处理单位来分: 字节流(8位二进制数据), 字符流(16位二进制数据). * * 3) 从是否有数据源来分: 节点流(有数据源), 处理流(必须套在节点流上). * * 3.在Java语言中,所有流类均来自