基本类型序列化和反序列化

最新推荐文章于 2023-07-06 17:40:08 发布
最新推荐文章于 2023-07-06 17:40:08 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： 网络通信 文章标签： 网络序列化 C++ 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gamekit/article/details/53838781
版权

基本类型序列化和反序列化

TypeDef.h源码

#pragma once
#include "stdafx.h"
typedef bool Bool;
typedef unsigned char Byte;
typedef char SByte;
typedef short Int16;
typedef unsigned short UInt16;
typedef int Int32;
typedef unsigned int UInt32;
typedef long long Int64;
typedef unsigned long long UInt64;
typedef float Float;
typedef double Double;
typedef char* CString;

BinaryReader.h源码

#pragma once
#include "stdafx.h"
#include "TypeDef.h"
#include <string>
using namespace std;
class BinaryReader
{
private:
    Byte* m_byteArray;
    Int32 m_byteArrayLen;
    Int32 m_position;
    Int32 Read7BitEncodedInt();
public:
    BinaryReader(Byte* byteArray=NULL, Int32 len=0);
    Bool ReadBoolean();
    Byte ReadByte();
    Int16 ReadInt16();
    UInt16 ReadUInt16();
    Int32 ReadInt32();
    UInt32 ReadUInt32();
    Int64 ReadInt64();
    UInt64 ReadUInt64();
    CString ReadCString();
    string ReadString();
    Float ReadSingle();
    Double ReadDouble();
    Int32 GetPosition();
    void SetPosition(Int32 v);
    void Reset(Byte* byteArray, int byteArrayLen);
};

BinaryReader.cpp源码

#include "stdafx.h"
#include "BinaryReader.h"
#include <string>
using namespace std;
BinaryReader::BinaryReader(Byte* byteArray, Int32 byteLen)
{
    m_byteArray = byteArray;
    m_byteArrayLen = byteLen;
    m_position = 0;
}
Int32 BinaryReader::GetPosition()
{
    return m_position;
}
void BinaryReader::SetPosition(Int32 v)
{
    if (v > m_byteArrayLen || v < 0)
    {
        return;
    }
    m_position = v;
}
void BinaryReader::Reset(Byte* byteArray,int byteArrayLen)
{
    m_byteArray = byteArray;
    m_byteArrayLen = byteArrayLen;
    m_position = 0;
}

bool BinaryReader::ReadBoolean()
{
    return (m_byteArray[m_position++] != 0);
}
Byte BinaryReader::ReadByte()
{
    return m_byteArray[m_position++];
}
Int16 BinaryReader::ReadInt16()
{
    Int16 v = (Int16)(m_byteArray[m_position] | m_byteArray[m_position+1] << 8);
    m_position += 2;
    return v;
}
UInt16 BinaryReader::ReadUInt16()
{
    UInt16 v =  (UInt16)(m_byteArray[m_position] | m_byteArray[m_position+1] << 8);
    m_position += 2;
    return v;
}

Int32 BinaryReader::ReadInt32()
{
    Int32 v = (Int32)(m_byteArray[m_position] | m_byteArray[m_position+1] << 8
        | m_byteArray[m_position+2] << 16 | m_byteArray[m_position+3] << 24);
    m_position += 4;
    return v;
}

UInt32 BinaryReader::ReadUInt32()
{
    UInt32 v = (UInt32)(m_byteArray[m_position] | m_byteArray[m_position+1] << 8
        | m_byteArray[m_position+2] << 16 | m_byteArray[m_position+3] << 24);
    m_position += 4;
    return v;

}

Int64 BinaryReader::ReadInt64()
{
    UInt32 lo = (UInt32)(m_byteArray[m_position] | m_byteArray[m_position+1] << 8 |
        m_byteArray[m_position+2] << 16 | m_byteArray[m_position+3] << 24);
    UInt32 hi = (UInt32)(m_byteArray[m_position+4] | m_byteArray[m_position+5] << 8 |
        m_byteArray[m_position+6] << 16 | m_byteArray[m_position+7] << 24);
    m_position += 8;
    return (Int64)((UInt64)hi) << 32 | lo;
}
UInt64 BinaryReader::ReadUInt64()
{
    UInt32 lo = (UInt32)(m_byteArray[m_position] | m_byteArray[m_position+1] << 8 |
        m_byteArray[m_position+2] << 16 | m_byteArray[m_position+3] << 24);
    UInt32 hi = (UInt32)(m_byteArray[m_position+4] | m_byteArray[m_position+5] << 8 |
        m_byteArray[m_position+6] << 16 | m_byteArray[m_position+7] << 24);
    m_position += 8;
    return ((UInt64)hi) << 32 | lo;
}

Float BinaryReader::ReadSingle()
{
    UInt32 tmpBuffer = (UInt32)(m_byteArray[m_position] | m_byteArray[m_position+1] << 8 |
        m_byteArray[m_position+2] << 16 | m_byteArray[m_position+3] << 24);
    m_position += 4;
    return *((Float*)&tmpBuffer);
}
Double BinaryReader::ReadDouble()
{
    UInt32 lo = (UInt32)(m_byteArray[m_position] | (m_byteArray[m_position + 1] << 8) |
        (m_byteArray[m_position + 2] << 16) | (m_byteArray[m_position + 3] << 24));
    UInt32 hi = (UInt32)(m_byteArray[m_position + 4] | (m_byteArray[m_position + 5 ] << 8) |
        (m_byteArray[m_position + 6 ] << 16) | (m_byteArray[m_position + 7] << 24));
    m_position += 8;
    UInt64 tmpBuffer = (((UInt64)hi) << 32) | lo;
    return *((Double*)&tmpBuffer);
}

CString BinaryReader::ReadCString()
{
    Int32 len = Read7BitEncodedInt();
    CString bytes = new SByte[len + 1];
    memcpy(bytes, m_byteArray + m_position, len);
    m_position += len;
    bytes[len] = '\0';
    return bytes;
}

string BinaryReader::ReadString()
{
    SByte* cStr = ReadCString();
    string s(cStr);
    return s;
}


int BinaryReader::Read7BitEncodedInt()
{
    // Read out an Int32 7 bits at a time.  The high bit 
    // of the byte when on means to continue reading more bytes.
    Int32 count = 0;
    Int32 shift = 0;
    Byte b;
    for (int i = 0; i<5; i++)
    {
        // Check for a corrupted stream.  Read a max of 5 bytes. 
        // In a future version, add a DataFormatException. 
        if (shift == 5 * 7) // 5 bytes max per Int32, shift += 7
            return 0;
        // ReadByte handles end of stream cases for us.
        b = ReadByte();
        count |= (b & 0x7F) << shift;
        shift += 7;
        if ((b & 0x80) == 0)
        {
            break;
        }
    }
    //count -= 1;  // Write的时候默认加了1
    return count;
}

BinaryWriter.h源码

#pragma once
#include "stdafx.h"
#include "TypeDef.h"
#include <string>
using namespace std;
class BinaryWriter
{
private:
    Byte* byteArray;
    int capacity;
    int position;
    void Write7BitEncodedInt(Int32 v);
public:
    BinaryWriter(int capacity = 32);
    Int32 GetPosition();
    void SetPosition(Int32 v);
    Int32 GetCapacity();
    void SetCapacity(Int32 v);
    void CheckCapacity(Int32 addCount);
    void Write(Bool value);
    void Write(Byte v);
    void Write(Byte* buffer, Int32 len);

    void Write(Double value);
    void Write(Int16 value);
    void Write(UInt16 value);

    void Write(Int32 value);

    void Write(UInt32 value);
    void Write(Int64 v);
    void Write(UInt64 v);
    void Write(Float v);
    void Write(string v);
    void Write(CString v);
    Byte* GetBytes();
    Int32 GetByteLen();
};

BinaryWriter.h源码

#include "stdafx.h"
#include "BinaryWriter.h"

BinaryWriter::BinaryWriter(int capacity)
{
    byteArray = new Byte[capacity];
    this->capacity = capacity;
    position = 0;
}
Int32 BinaryWriter::GetPosition()
{
    return position;
}
void BinaryWriter::SetPosition(Int32 v)
{
    if (v > capacity)
    {
        CheckCapacity(v - capacity);
    }
    position = v;
}
Int32 BinaryWriter::GetCapacity()
{
    return capacity;
}
void BinaryWriter::SetCapacity(Int32 v)
{
    if (v != capacity)
    {
        if (capacity < position)
        {
            return;
        }
        if (v > 0)
        {
            Byte* newBuffer = new Byte[v];
            if (position > 0) memcpy(newBuffer, byteArray, position);
            byteArray = newBuffer;
        }
        else {
            byteArray = NULL;
        }
        capacity = v;
    }
}
void BinaryWriter::CheckCapacity(Int32 addCount)
{
    Int32 newCapacity = position + addCount;
    if (newCapacity > capacity)
    {
        if (newCapacity < 256)
            newCapacity = 256;
        if (newCapacity < capacity * 2)
            newCapacity = capacity * 2;
        SetCapacity(newCapacity);
    }
}
void BinaryWriter::Write(Bool value)
{
    CheckCapacity(1);
    byteArray[position++] = (Byte)(value ? 1 : 0);
}
void BinaryWriter::Write(Byte v)
{
    CheckCapacity(1);
    byteArray[position++] = v;
}
void BinaryWriter::Write(Byte* buffer, Int32 len)
{
    if (buffer == NULL || len == 0)
    {
        return;
    }
    CheckCapacity(len);
    memcpy(byteArray, buffer, len);
    position += len;
}

void BinaryWriter::Write(Double value)
{
    CheckCapacity(8);
    UInt64 TmpValue = *(UInt64*)&value;
    byteArray[position++] = (Byte)TmpValue;
    byteArray[position++] = (Byte)(TmpValue >> 8);
    byteArray[position++] = (Byte)(TmpValue >> 16);
    byteArray[position++] = (Byte)(TmpValue >> 24);
    byteArray[position++] = (Byte)(TmpValue >> 32);
    byteArray[position++] = (Byte)(TmpValue >> 40);
    byteArray[position++] = (Byte)(TmpValue >> 48);
    byteArray[position++] = (Byte)(TmpValue >> 56);
}

void BinaryWriter::Write(Int16 value)
{
    CheckCapacity(2);
    byteArray[position++] = (Byte)value;
    byteArray[position++] = (Byte)(value >> 8);
}
void BinaryWriter::Write(UInt16 value)
{
    CheckCapacity(2);
    byteArray[position++] = (Byte)value;
    byteArray[position++] = (Byte)(value >> 8);
}

void BinaryWriter::Write(Int32 value)
{
    CheckCapacity(4);
    byteArray[position++] = (Byte)value;
    byteArray[position++] = (Byte)(value >> 8);
    byteArray[position++] = (Byte)(value >> 16);
    byteArray[position++] = (Byte)(value >> 24);

}

void BinaryWriter::Write(UInt32 value)
{
    CheckCapacity(4);
    byteArray[position++] = (Byte)value;
    byteArray[position++] = (Byte)(value >> 8);
    byteArray[position++] = (Byte)(value >> 16);
    byteArray[position++] = (Byte)(value >> 24);
}

void BinaryWriter::Write(Int64 v)
{
    CheckCapacity(8);
    byteArray[position++] = (Byte)v;
    byteArray[position++] = (Byte)(v >> 8);
    byteArray[position++] = (Byte)(v >> 16);
    byteArray[position++] = (Byte)(v >> 24);
    byteArray[position++] = (Byte)(v >> 32);
    byteArray[position++] = (Byte)(v >> 40);
    byteArray[position++] = (Byte)(v >> 48);
    byteArray[position++] = (Byte)(v >> 56);
}

void BinaryWriter::Write(UInt64 v)
{
    CheckCapacity(8);
    byteArray[position++] = (Byte)v;
    byteArray[position++] = (Byte)(v >> 8);
    byteArray[position++] = (Byte)(v >> 16);
    byteArray[position++] = (Byte)(v >> 24);
    byteArray[position++] = (Byte)(v >> 32);
    byteArray[position++] = (Byte)(v >> 40);
    byteArray[position++] = (Byte)(v >> 48);
    byteArray[position++] = (Byte)(v >> 56);
}

void BinaryWriter::Write(Float v)
{
    CheckCapacity(4);
    UInt32 tmpValue = *(UInt32*)&v;
    byteArray[position++] = (Byte)tmpValue;
    byteArray[position++] = (Byte)(tmpValue >> 8);
    byteArray[position++] = (Byte)(tmpValue >> 16);
    byteArray[position++] = (Byte)(tmpValue >> 24);
}

void BinaryWriter::Write(string v)
{
    if (v.size() == 0)
    {
        Write7BitEncodedInt(0);
        return;
    }
    const char* cStr = v.c_str();
    Int32 len = v.size();
    Write7BitEncodedInt(len);
    CheckCapacity(len);
    memcpy(byteArray+ position,cStr,len);
    position += len;
}
void BinaryWriter::Write(CString v)
{
    if (v == NULL)
    {
        Write7BitEncodedInt(0);
        return;
    }
    int len = strlen((const char*)v);
    Write7BitEncodedInt(len);
    CheckCapacity(len);
    memcpy(byteArray + position, v, len);
    position += len;
}
void BinaryWriter::Write7BitEncodedInt(Int32 v)
{
    while (v >= 0x80)
    {
        Write((Byte)(v | 0x80));
        v >>= 7;
    }
    Write((Byte)v);
}

Byte* BinaryWriter::GetBytes()
{
    Byte* bytes = new Byte[position];
    memcpy(bytes, byteArray, position);
    return bytes;
}
Int32 BinaryWriter::GetByteLen()
{
    return position;
}

BinaryWriter.cpp源码

#include "stdafx.h"
#include "BinaryWriter.h"

BinaryWriter::BinaryWriter(int capacity)
{
    byteArray = new Byte[capacity];
    this->capacity = capacity;
    position = 0;
}
Int32 BinaryWriter::GetPosition()
{
    return position;
}
void BinaryWriter::SetPosition(Int32 v)
{
    if (v > capacity)
    {
        CheckCapacity(v - capacity);
    }
    position = v;
}
Int32 BinaryWriter::GetCapacity()
{
    return capacity;
}
void BinaryWriter::SetCapacity(Int32 v)
{
    if (v != capacity)
    {
        if (capacity < position)
        {
            return;
        }
        if (v > 0)
        {
            Byte* newBuffer = new Byte[v];
            if (position > 0) memcpy(newBuffer, byteArray, position);
            byteArray = newBuffer;
        }
        else {
            byteArray = NULL;
        }
        capacity = v;
    }
}
void BinaryWriter::CheckCapacity(Int32 addCount)
{
    Int32 newCapacity = position + addCount;
    if (newCapacity > capacity)
    {
        if (newCapacity < 256)
            newCapacity = 256;
        if (newCapacity < capacity * 2)
            newCapacity = capacity * 2;
        SetCapacity(newCapacity);
    }
}
void BinaryWriter::Write(Bool value)
{
    CheckCapacity(1);
    byteArray[position++] = (Byte)(value ? 1 : 0);
}
void BinaryWriter::Write(Byte v)
{
    CheckCapacity(1);
    byteArray[position++] = v;
}
void BinaryWriter::Write(Byte* buffer, Int32 len)
{
    if (buffer == NULL || len == 0)
    {
        return;
    }
    CheckCapacity(len);
    memcpy(byteArray, buffer, len);
    position += len;
}

void BinaryWriter::Write(Double value)
{
    CheckCapacity(8);
    UInt64 TmpValue = *(UInt64*)&value;
    byteArray[position++] = (Byte)TmpValue;
    byteArray[position++] = (Byte)(TmpValue >> 8);
    byteArray[position++] = (Byte)(TmpValue >> 16);
    byteArray[position++] = (Byte)(TmpValue >> 24);
    byteArray[position++] = (Byte)(TmpValue >> 32);
    byteArray[position++] = (Byte)(TmpValue >> 40);
    byteArray[position++] = (Byte)(TmpValue >> 48);
    byteArray[position++] = (Byte)(TmpValue >> 56);
}

void BinaryWriter::Write(Int16 value)
{
    CheckCapacity(2);
    byteArray[position++] = (Byte)value;
    byteArray[position++] = (Byte)(value >> 8);
}
void BinaryWriter::Write(UInt16 value)
{
    CheckCapacity(2);
    byteArray[position++] = (Byte)value;
    byteArray[position++] = (Byte)(value >> 8);
}

void BinaryWriter::Write(Int32 value)
{
    CheckCapacity(4);
    byteArray[position++] = (Byte)value;
    byteArray[position++] = (Byte)(value >> 8);
    byteArray[position++] = (Byte)(value >> 16);
    byteArray[position++] = (Byte)(value >> 24);

}

void BinaryWriter::Write(UInt32 value)
{
    CheckCapacity(4);
    byteArray[position++] = (Byte)value;
    byteArray[position++] = (Byte)(value >> 8);
    byteArray[position++] = (Byte)(value >> 16);
    byteArray[position++] = (Byte)(value >> 24);
}

void BinaryWriter::Write(Int64 v)
{
    CheckCapacity(8);
    byteArray[position++] = (Byte)v;
    byteArray[position++] = (Byte)(v >> 8);
    byteArray[position++] = (Byte)(v >> 16);
    byteArray[position++] = (Byte)(v >> 24);
    byteArray[position++] = (Byte)(v >> 32);
    byteArray[position++] = (Byte)(v >> 40);
    byteArray[position++] = (Byte)(v >> 48);
    byteArray[position++] = (Byte)(v >> 56);
}

void BinaryWriter::Write(UInt64 v)
{
    CheckCapacity(8);
    byteArray[position++] = (Byte)v;
    byteArray[position++] = (Byte)(v >> 8);
    byteArray[position++] = (Byte)(v >> 16);
    byteArray[position++] = (Byte)(v >> 24);
    byteArray[position++] = (Byte)(v >> 32);
    byteArray[position++] = (Byte)(v >> 40);
    byteArray[position++] = (Byte)(v >> 48);
    byteArray[position++] = (Byte)(v >> 56);
}

void BinaryWriter::Write(Float v)
{
    CheckCapacity(4);
    UInt32 tmpValue = *(UInt32*)&v;
    byteArray[position++] = (Byte)tmpValue;
    byteArray[position++] = (Byte)(tmpValue >> 8);
    byteArray[position++] = (Byte)(tmpValue >> 16);
    byteArray[position++] = (Byte)(tmpValue >> 24);
}

void BinaryWriter::Write(string v)
{
    if (v.size() == 0)
    {
        Write7BitEncodedInt(0);
        return;
    }
    const char* cStr = v.c_str();
    Int32 len = v.size();
    Write7BitEncodedInt(len);
    CheckCapacity(len);
    memcpy(byteArray+ position,cStr,len);
    position += len;
}
void BinaryWriter::Write(CString v)
{
    if (v == NULL)
    {
        Write7BitEncodedInt(0);
        return;
    }
    int len = strlen((const char*)v);
    Write7BitEncodedInt(len);
    CheckCapacity(len);
    memcpy(byteArray + position, v, len);
    position += len;
}
void BinaryWriter::Write7BitEncodedInt(Int32 v)
{
    while (v >= 0x80)
    {
        Write((Byte)(v | 0x80));
        v >>= 7;
    }
    Write((Byte)v);
}

Byte* BinaryWriter::GetBytes()
{
    Byte* bytes = new Byte[position];
    memcpy(bytes, byteArray, position);
    return bytes;
}
Int32 BinaryWriter::GetByteLen()
{
    return position;
}
游戏猫
关注
专栏目录
对含有自定义类的的类的反序列化
mozai147的博客
03-29 512
参考https://www.cnblogs.com/insaneXs/p/9515803.html 在反序列化含有自定义枚举类的类时，自定义枚举类的属性反序列化失败， 具体体现为得到枚举类的属性值时为null 解决方法： 1 添加自定义的编解码器： publicclassEventTypeCodeimplementsObjectSerializer,ObjectDeserial...
ASPNET中JSON的序列化和反序列化的方法
10-21
下面将详细介绍***中JSON序列化和反序列化的几种方法以及如何处理日期时间类型的序列化和反序列化。 首先，了解JSON的基本格式是非常重要的。JSON的数据结构由对象(Object)、数组(Array)、字符串(String)、数字...
反序列化与基本类型
阿萨的专栏
11-11 259
需求 json字符串(string)->reflect.type，无法知道是否为基本类型。 步骤 判断是type是否为初始类型 public static boolean isPrimitiveType(Type type) { Class<?> typeClz = (Class<?>) type; return Stream.of(String.class, Integer.class, Double.class, Float.cl
序列化对象的类型，两种方式
程序元
04-18 457
实现java.io.Serializable; 实现java.io.Externalizable，当时实现这个接口必须重写两个抽象方法 void writeExternal(ObjectOutput out) void readExternal(ObjectInput in) 有了这两个方法，如何序列化和反序列化由程序员说了算。 ...
数据类型和序列化
qq_43668119的博客
03-30 381
内存和磁盘之间是频繁的进行数据的交换的。 序列化： 把内存中的对象以字节数组的形式写入磁盘中的过程，就叫做序列化 反序列化： 把磁盘中的字节数组转换成对象的形式写入内存的过程。 java中的序列化： Java中的序列化是比较重量级的序列化，不适用于海量数据的处理。 hadoop中的序列化 在java序列化基础上按照...
各种数据类型的序列化
12-06 481
void MyClass::Serialize( CArchive& ar ) { MyBasicClass::Serialize(ar);//基类 if(ar.IsLoading())//读取 { ar >> m_nPayNo;//整形，double形, long ar.Read(&m_bValue,sizeof(m_bValue));//bool形 ar >> m_sValu
Java各种数据类型序列化
p7+的博客
10-18 2936
对象序列化是一个用于将对象状态转换为字节流的过程，可以将其保存到磁盘文件中或通过网络发送到任何其他程序；从字节流创建对象的相反的过程称为反序列化。 可以理解为序列化是将数据转换成byte[]的表示方式。 对象序列化： 首先要实现Serializable接口 使用ObjectOutputStream序列化，返回byte[]，使用ObjectInputStream反序列化byte[]为对象 fast...
Java对象的序列化和反序列化实践
12-22
　把字节序列恢复为Java对象的过程称为对象的反序列化。 　对象的序列化主要有两种用途： 　1）把对象的字节序列地保存到硬盘上，通常存放在一个文件中； 　2）在网络上传送对象的字节序列。 　一、JDK类库...
深入理解C#序列化与反序列化的详解
01-01
在我们深入探讨C#序列化和反序列化之前我们先要明白什么是序列化，它又称串行化，是.NET运行时环境用来支持用户定义类型的流化的机制。序列化就是把一个对象保存到一个文件或数据库字段中去，反序列化就是在适当的...
详解PHP序列化和反序列化原理
10-18
关于序列化的性能问题，一方面要考虑时间性能，即序列化和反序列化的速度，另一方面要考虑空间性能，即序列化后的数据大小。PHP序列化的时间性能通常不是问题，但空间性能有时需要注意，尤其是当对象很大或包含大量...
ffmpeg需要用到的头文件inttypes.h inttypedef.h stdint.h
06-11
做音视频用ffmpeg库的时候必须的头文件。
JAVA序列化和反序列化的底层实现原理解析
08-25
JAVA序列化和反序列化的底层实现原理解析 一、基本概念 JAVA序列化是指把Java对象转换为字节序列的过程，而Java反序列化是指把字节序列恢复为Java对象的过程。序列化是把对象转换成有序字节流，以便在网络上传输...
一文带你了解序列化与反序列化基本原理与操作
最新发布
m0_68987535的博客
07-06 1万+
序列化是指将对象转换为字节序列的过程，以便于存储或传输。在序列化过程中，对象的状态信息将被转换为字节流，可以保存到文件中或通过网络传输给其他计算机。反序列化则是将字节序列恢复为对象的过程。通过反序列化操作，可以从存储的字节流中还原对象的状态。这使得可以在程序重启后，读取保存的字节流并重新构造对象，从而快速恢复对象的状态。在分布式系统中，可以将对象进行序列化，并在不同的计算机之间进行传输。接收方可以通过反序列化操作将字节序列转换为可操作的对象。某些远程通信框架使用序列化和反序列化来实现远程方法调用。
各种类型数据对序列化的支持程度
狂健小夫的博客
03-17 1174
类型                                                              是否支持序列化 简单类型int，String，Boolean等                                 支持 String[]                                                         
Java的基本数据类型与流
mingjava的专栏
09-16 5711
<A title="文章标题：使用Java操作二进制文件作 者：mingjava更新时间：2004-9-11 16:00:49点击次数：17" href="http://www.j2medev.com/Article_Show.asp?ArticleID=80" target=_blank>使用Java操作二进制文件和<A title="文章标题：使用Java操作文本文件作
typedef
qq_52988578的博客
03-19 165
首先明白typedef是什么意思！ typedef:是类型定义的意思 例如： #include<stdio.h> typedef int s;//这里通过typedef将s变为int型 int main() //因此在下面可以使用s来代替int的作用 { s a=10; int b=10; printf("%d",a);//a,b都是int型变量 printf("\n%d",b); return 0; } 同时typedef经常用来声明结构体 #
C | typedef 类型定义
H_Expect的博客
07-24 868
typedef是在计算机编程语言中用来为复杂的声明定义简单的别名，它与宏定义有些差异。它本身是一种存储类的关键字，与auto、extern、mutable、static、register等关键字不能出现在同一个表达式中。 1.typedef 类型定义 (1) typedef unsigned long long int uint64; (2) typedef int Arr[10]; (3)...
.h文件中的typedef运用
菜鸟拥有不太多的知识
05-06 385
头文件的多重定义如何解决
关于使用typedef的注意事项
Dongzai_JJXY的博客
04-28 599
关于使用typedef的注意事项1，  基础夯实typedef是C语言的一个关键字，主要是用于代替原有的类型标识符，去修饰变量，数组等等，它并不能创造出一个新的类型标识符。 2，  使用实例（1）在.h文件，定义了一个结构体类。Eg:图1图1（2）在.c文件中，调用结构体的名，去修饰一个指针。正确情况下，用fifo已经可以表示该结构体的类型了，但是，如果在fifo前面再加struct去修饰，许多I...
Python Marshmallow 序列化与反序列化实战及验证
以下是一个基本的序列化和反序列化的例子： ```python from marshmallow import Schema, fields # 定义User Schema class UserSchema(Schema): name = fields.Str() age = fields.Int() # 用户对象 class User:...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值