C语言基于void*实现泛型容器化代码编程

已于 2022-07-04 09:08:49 修改
阅读量1.1k 收藏 3
点赞数 2
分类专栏： C 文章标签： c语言 c++
于 2022-07-03 22:04:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/su_fei_ma_su/article/details/125579847
版权

前情提要

上一篇博文 基于C语言实现泛型编程（抛砖引玉） 中实现了一种泛型窗口，和操作该窗口的一些泛型方法（算法）。但是实现泛型的方法太简单粗暴了，大体思路就是：

  1. 定义一个数据结构，存储数据，数据类型，窗口大小，序列号等，并在初始化时全部设定好。
  2. 每个函数中都获取该窗口的类型，然后根据类型的不同编写不同的实现。

虽然也实现了任意类型，任意长度的窗口，操作接口一致性，达到了最基础的泛型的要求，但是代码体积太过庞大，每次新增一个类型，就要改每个函数里的实现，这显然不符合我心中的版本。于是花了一天时间做了下优化。

文章目录

前言

C++通过模板，多态实现泛型编程，其中蕴含的细节编译器已经实现完全了。模板会根据传入类型，自动生成符合该类型的实现，也就是编译的时候帮你写好了这个类型对应的函数体，编译出的可执行文件当然会变大，臃肿，不过都是可以接收的。

C语言就没有这么幸运了，我刚开始看公司项目代码时，针对不同类型(uint8_t , int8_t , int , uint , float , double … )实现了很多个队列，栈，环形缓冲区，代码加起来大几千行，每种类型对应的接口还不一样，一个sort_uint8_t , sort_float … 都写了很多遍，看的人头痛。

于是想写一个类似C++ 中STL里实现的那种泛型容器，实现针对不同类型，接口一致化。

实现泛型的思路

泛型，统一不同的类型，对C程序员来讲应当很容易，所谓变量，不就是一个地址，加上从这个地址开始，有效数据长度，知道这两个信息，就等于能反推整个变量的值。

在这里插入图片描述
身为一个C程序员，应当从内存的角度，从编译器的角度去思考问题。这里就简化下模型，固定在32位系统下，忽略大小端，泛型的本质就是编译器掌握了变量的类型和变量地址，有了类型就知道从这个地址开始，往后(往前，根据出入栈模型不同)多少个字节是有意义的，从这个地址开始，往后多少个字节组合在一起，可以还原整个变量。

想保证接口统一，那么每个接口都通过void* 来操作容器，有了void * 就有了地址，现在还差长度，这个也简单，在初始化时根据容器类型，设定成员大小。

一、泛化的容器

C++ STL中实现了很多容器，和操作容器的算法库。这里就先实现一种，以后慢慢扩展整个项目。

泛化的容器选定为顺序表，理由就是简单，用途广泛。根据顺序表泛化窗口容器，这个叫法是个人习惯，叫顺序表是对的。基于窗口能轻松实现队列，栈，环形缓冲区等常用的数据结构。

想要一个窗口，就需要有窗口本体，窗口类型，窗口大小，窗口类型大小，序列码（判断窗口满没满），根据要求直接定义窗口结构体：

/**
 * @brief 该结构体用于构建基础窗口顺序表
 *        this structure is used to build the basic window sequence table
 */
typedef struct ValueWindowSquential
{
    char* type; // 窗口类型

    void* data; // 窗口本体

    uint16_t type_size; // 类型大小

    uint32_t max_size; // 窗口大小
 
    uint32_t sequence; // 序列号 

} ValueWindowSquential;

然后写一个初始化函数初始化整个窗口，包括窗口大小，窗口类型，成员类型大小等

// 定义需要泛化的类型，这里走查表法
typedef enum
{
    UINT8 = 0,
    INT,
    FLOAT,
    DOUBLE,

    ERROR

} TypeName;

const char* kValueTypeList[ ERROR + 1 ] = {

    "uint8_t",

    "int",
    "float",
    "double",

    "error",
};

/**
 * @brief 将字符串转换成TypeName
 *          private interface
 *
 * @param tmp
 * @return TypeName
 */
TypeName ChangeStringToEnum( const char* tmp )
{
    assert( tmp != NULL );

    TypeName return_tmp = ERROR;

    if ( strcmp( tmp, kValueTypeList[ UINT8 ] ) == 0 )
    {
        return_tmp = UINT8;
    }
    else if ( strcmp( tmp, kValueTypeList[ FLOAT ] ) == 0 )
    {
        return_tmp = FLOAT;
    }
    else if ( strcmp( tmp, kValueTypeList[ DOUBLE ] ) == 0 )
    {
        return_tmp = DOUBLE;
    }
    else if ( strcmp( tmp, kValueTypeList[ INT ] ) == 0 )
    {
        return_tmp = INT;
    }
    else
    {
        printf( "error char* input !!!" );
        assert( 0 );
    }
    return return_tmp;
}

// 初始化窗口
// Initialize window
void InitValueWindow( ValueWindowSquential* tmp, const char* type, uint32_t max_size )
{
    assert( tmp != NULL );

    tmp->type = ( char* ) malloc( strlen( type ) * sizeof( char ) );
    strncpy( tmp->type, type, strlen( type ) );

    tmp->max_size = max_size;
    tmp->sequence = 0;

    switch ( ChangeStringToEnum( tmp->type ) )
    {
        case UINT8: {
            tmp->data = ( uint8_t* ) malloc( max_size * sizeof( uint8_t ) );
            memset( tmp->data, 0, tmp->max_size );

            tmp->type_size = sizeof( uint8_t );
        }
        break;

        case INT: {
            tmp->data = ( int* ) malloc( max_size * sizeof( int ) );
            memset( tmp->data, 0, tmp->max_size );

            tmp->type_size = sizeof( int );
        }
        break;

        case FLOAT: {
            tmp->data = ( float* ) malloc( max_size * sizeof( float ) );
            memset( tmp->data, 0, tmp->max_size );

            tmp->type_size = sizeof( float );
        }
        break;

        case DOUBLE: {
            tmp->data = ( double* ) malloc( max_size * sizeof( double ) );
            memset( tmp->data, 0, tmp->max_size );

            tmp->type_size = sizeof( double );
        }
        break;

        default: {
            printf( "error tmp->type input !!!" );
            assert( 0 );
        }
        break;
    }

    printf( "type is : %s , max_size is : %d , type_size is : %d \r\n",
            tmp->type, max_size, tmp->type_size );
}

// 重置/销毁窗口
void ResetValueWindow( ValueWindowSquential* tmp )
{
    tmp->sequence  = 0;
    tmp->max_size  = 0;
    tmp->type_size = 0;

    if ( tmp->data != NULL )
    {
        free( tmp->data );
        tmp->data = NULL;
    }

    if ( tmp->type != NULL )
    {
        free( tmp->type );
        tmp->type = NULL;
    }
}

调用初始化创建窗口也很简单

// 1. 创建一个泛型窗口，并以float类型，10个窗口大小初始化
    ValueWindowSquential tmp;
    InitValueWindow( &tmp, kValueTypeList[ FLOAT ], 10 );

二、通过void* 泛化窗口

这里指的是，任何操作容器的接口，都必须通过一个void*指针，这样才能忽略参数类型等因素。

工具函数

正常情况下，操作一个窗口（顺序表）无外乎以下几种操作方式：

  1. 实现 buffer[i] = res; 设置任意成员的值
  2. 实现 res = buffer[i]; 获取任意成员的值
  3. 实现 buffer[i] = buffer[j]; 将任意成员的值赋值给任意成员
  4. 实现 buffer[i] <=> buffer[j] ; 实现任意成员比大小
  5. 实现 swap(i,j); 交换任意两个成员值

现在有的信息是什么？窗口中任意成员的地址，任意成员类型所占的大小（几个byte），知道这两个信息，就可以定义一些工具函数来实现上面的需求：

#ifndef __GENERICS_UTIL_H
#define __GENERICS_UTIL_H

#include "test_generics.h"

/*
    1. 实现 buffer[i] = res; 设置任意成员的值
    2. 实现 res = buffer[i]; 获取任意成员的值
    3. 实现 buffer[i] = buffer[j]; 将任意成员的值赋值给任意成员
    4. 实现 buffer[i] <=> buffer[j] ; 实现任意成员比大小
    5. 实现 swap(i,j); 交换任意两个成员值
*/

// 工具函数 获取窗口任意下标对应的地址 不对外暴露
static inline void* GetMemberAddress( ValueWindowSquential* tmp, int i )
{
    return ( void* ) ( tmp->data + i * tmp->type_size );
}

// 打印任意类型数据的十六进制编码 调试用
static inline void ShowTypeChangeToHex( ValueWindowSquential* tmp, int i )
{
    uint8_t* res = ( uint8_t* ) GetMemberAddress( tmp, i );
    for ( int i = 0; i < tmp->type_size; i++ )
    {
        printf( "Hex : 0x%x \r\n", *res++ );
    }
}

// 1. 设置任意成员的值
static inline void SetMemberValue( ValueWindowSquential* tmp, void* value, int i )
{
    memcpy( GetMemberAddress( tmp, i ), value, tmp->type_size );
}

// 2. 获取任意成员的值
static inline void GetMemberValue( ValueWindowSquential* tmp, void* value, int i )
{
    memcpy( value, GetMemberAddress( tmp, i ), tmp->type_size );
}

// 3. 将任意成员的值赋值给任意成员
static inline void SetMemberToMember( ValueWindowSquential* tmp, int i, int j )
{
    memcpy( GetMemberAddress( tmp, i ), GetMemberAddress( tmp, j ), tmp->type_size );
}

// 4. 对比两个成员大小，顺序为 i > = < j
static inline ComparMemberValue( ValueWindowSquential* tmp, int i, int j )
{
    memcmp( GetMemberAddress( tmp, i ), GetMemberAddress( tmp, j ), tmp->type_size );
}

// 5. 交换任意两个成员值
static inline void SwapMemberValue( ValueWindowSquential* tmp, int i, int j )
{
    void* tmp_value = ( void* ) malloc( tmp->type_size );

    GetMemberValue( tmp, tmp_value, i );
    SetMemberToMember( tmp, i, j );
    SetMemberValue( tmp, tmp_value, j );

    free( tmp_value );
}

#endif // __GENERICS_UTIL_H

代码量很小，但是已经实现了上面五个需求，有了这五个工具函数，就可以实现一些顶层函数的设计了。

填充窗口

有了上面五个工具函数，就可以随意操作窗口了，这里先实现两种插入数据接口：
可以一看相比第一版实现，通过void* + 类型大小这种方式非常的清爽，寥寥几行就能实现针对不同类型的泛型插入。

// 滑动往窗口插入数据
SlideWindowState ValueWindowSlideInsert( ValueWindowSquential* tmp, void* data )
{
    SlideWindowState return_tmp = kWindowIsNotFull;

    for ( int i = 1; i < tmp->max_size; i++ )
    {
        SetMemberToMember( tmp, i - 1, i );
    }
    SetMemberValue( tmp, data, tmp->max_size - 1 );

    // just for return window state
    if ( ++tmp->sequence >= tmp->max_size )
    {
        return_tmp    = kWindowIsSliding;
        tmp->sequence = tmp->max_size;
    }

    return return_tmp;
}

// 插入数据直到填满整个窗口
FixedWindowState ValueWindowFixedInsert( ValueWindowSquential* tmp, void* data )
{
    FixedWindowState return_tmp = kWindowNotFull;

    SetMemberValue( tmp, data, tmp->sequence );

    if ( ++tmp->sequence >= tmp->max_size )
    {
        tmp->sequence = 0;
        return_tmp    = kWindowAlreadyFull;
    }
    return return_tmp;
}

ValueWindowSlideInsert 是滑动插入，遵循先入先出原则，就是普通的滑动窗，窗口满了后，每次插入丢掉最老的数据，窗口状态分为未满和滑动中两种，开始滑动后就一直处于滑动状态。

以下状态就是插入中：
在这里插入图片描述
以下状态就是插满了：
在这里插入图片描述
满了以后，每次插入所有数据整体往后移，丢掉最后一个，插入数据到最前面：
在这里插入图片描述

ValueWindowFixedInsert 是固定窗口插入，就是窗口填充满以后，反馈窗口已满，给到用户去操作，再次插入时丢掉整个窗口中的数据，从头插入，并且反馈窗口未满状态。

这种插入方式会让数据降频，什么意思呢，就是比如传感器数据10ms来一次，窗口大小为10个数据，那么就需要插入十次，才能使用窗口一次，否则窗口未插入满不能被使用。

操作窗口

C++ STL中针对容器实现了很多算法，不同类型，不同长度的容器扔到同一个算法里，就能得到期望的结果。有了上面五个工具函数，我们也能很轻易实现这个功能。

先把最通用的排序功能实现：

/**
 * @brief 对窗口进行冒泡排序
 *
 * @param tmp window
 */
static inline void ValueWindowBubbleSort( ValueWindowSquential* tmp )
{
    bool is_end_loop = true;

    for ( int i = 0; i < tmp->max_size && is_end_loop; i++ )
    {
        is_end_loop = false;
        for ( int j = tmp->max_size - 1; j >= i; j-- )
        {
            if ( ComparMemberValue( tmp, j - 1, j ) > 0 )
            {
                is_end_loop = true;
                SwapMemberValue( tmp, j - 1, j );
            }
        }
    }
}

/**
 * @brief 对窗口进行选择排序
 *
 * @param tmp window
 */
static inline void ValueWindowSelectSort( ValueWindowSquential* tmp )
{
    int min_index = 0;

    for ( int i = 0; i < tmp->max_size; i++ )
    {
        min_index = i;

        for ( int j = i; j < tmp->max_size; j++ )
        {
            if ( ComparMemberValue( tmp, min_index, j ) > 0 )
            {
                min_index = j;
            }
        }
        if ( i != min_index )
        {
            SwapMemberValue( tmp, i, min_index );
        }
    }
}

/**
 * @brief 对窗口进行直接插入排序
 *
 * @param tmp window
 */
static inline void ValueWindowInsertSort( ValueWindowSquential* tmp )
{
    void* tmp_value = ( void* ) malloc( tmp->type_size );
    int   j         = 0;

    for ( int i = 1; i < tmp->max_size; i++ )
    {
        if ( ComparMemberValue( tmp, i - 1, i ) > 0 )
        {
            GetMemberValue( tmp, tmp_value, i );

            for ( j = i - 1; ComparMemberValueFree( tmp, j, tmp_value ) && j >= 0; j-- )
            {
                SetMemberToMember( tmp, j + 1, j );
            }
            SetMemberValue( tmp, tmp_value, j + 1 );
        }
    }

    free( tmp_value );
}

无论什么类型，无论多大容量，扔到算法接口中，都能给你处理好，让使用者不需要管太多内部细节。

踩坑历程

int main( void )
{
    // 1. 创建一个泛型窗口，并以float类型，10个窗口大小初始化
    ValueWindowSquential tmp;
    InitValueWindow( &tmp, kValueTypeList[ INT ], 10 );

    int insert_data = 0;
    for ( int i = 0; i < tmp.max_size; i++ )
    {
        // 2. 插入数据到窗口中，直到接收到窗口满反馈
        insert_data = ( tmp.max_size - i ) * 11;
        if ( kWindowAlreadyFull == ValueWindowFixedInsert( &tmp, &insert_data ) )
        {
            // 3. 打印排序前窗口
            printf( "start sort \r\n" );
            ShowTheWindow( &tmp );

            // 4. 通过直接插入排序法对窗口进行排序
            ValueWindowInsertSort( &tmp );

            // 5. 打印排序后的窗口
            printf( "end sort \r\n" );
            ShowTheWindow( &tmp );

            break;
        }
    }
    ResetValueWindow( &tmp );

    printf( "test generics \r\n" );
    return 0;
}

可以看到，插入前的容器内部是按照插入顺序，数值从大到小，排序后能够从小到大。整个用法除了初始化时需要根据期望的窗口类型和窗口大小设置一下，以后的接口都无需这些操作。
请添加图片描述

浮点数的坑

这里有个奇怪的现象，当使用浮点数类型窗口时，排序失效了！

请添加图片描述
gdb跑了下发现是上面一个工具函数的锅：

// 4. 对比两个成员大小，顺序为 i > = < j
static inline ComparMemberValue( ValueWindowSquential* tmp, int i, int j )
{
    memcmp( GetMemberAddress( tmp, i ), GetMemberAddress( tmp, j ), tmp->type_size );
}

这里我通过 memcmp 比较两段内存的大小，整型无论有无符号均没问题，但是一到浮点数不行了。看了下gcc实现的源码，memcmp 内部会用一个char* 去出该地址的首字节，若首字节就相等，就认为相等，不往后比较剩下的字节大小了，这样肯定是不行的。于是就重写了memcmp ，将一个数据的所有有效字节都遍历一遍。

// 4. 对比两个成员大小，顺序为 i > = < j
static inline int ComparMemberValue( ValueWindowSquential* tmp, int i, int j )
{
    int res = 0;

    uint8_t* value_i = ( uint8_t* ) GetMemberAddress( tmp, i );
    uint8_t* value_j = ( uint8_t* ) GetMemberAddress( tmp, j );

    for ( int k = tmp->type_size - 1; k >= 0; k-- )
    {
        res = memcmp( value_i + k, value_j + k, sizeof( uint8_t ) );
        if ( res != 0 )
        {
            break;
        }
    }
    return res;
}

// 4. 对比任意成员与任意值的大小,服务于插入排序
static inline int ComparMemberValueFree( ValueWindowSquential* tmp, int i, void* j )
{
    int res = 0;

    uint8_t* value_i = ( uint8_t* ) GetMemberAddress( tmp, i );
    uint8_t* value_j = ( uint8_t* ) j;

    for ( int k = tmp->type_size - 1; k >= 0; k-- )
    {
        res = memcmp( value_i + k, value_j + k, sizeof( uint8_t ) );
        if ( res != 0 )
        {
            break;
        }
    }
    return res;
}

在这里插入图片描述

负数的坑

浮点数排序也能成功了！就在我以为万事大吉的时候，我试了一下负数，结果又不行了。。。

在这里插入图片描述
一模一样的代码，改成负数就不行了，不用问，还是写的比较成员大小函数的锅，查了下资料，是可以通过一个数字的十六进制来辨识一个数是否为负数的。针对这种情况做一下特殊处理吧。。。同时决定不用 memcmp ，不方便调试。

// 工具函数 获取任意值的正负 不对外暴露
// return  true  负数
//         false 正数（包括0）
static inline bool GetValuePositive( ValueWindowSquential* tmp, int i )
{
    uint8_t res = *( ( uint8_t* ) GetMemberAddress( tmp, i ) + tmp->type_size - 1 );
    return res & ( 1 << 7 );
}

// 4. 对比两个成员大小，顺序为 i > = < j
static inline int ComparMemberValue( ValueWindowSquential* tmp, int i, int j )
{
    int res = 0;

    bool i_position = GetValuePositive( tmp, i );
    bool j_position = GetValuePositive( tmp, j );

    uint8_t* value_i = ( uint8_t* ) GetMemberAddress( tmp, i );
    uint8_t* value_j = ( uint8_t* ) GetMemberAddress( tmp, j );

    do
    {
        if ( i_position != j_position )
        {
            res = ( i_position == false ) ? 1 : -1;
            break;
        }

        for ( int k = tmp->type_size - 1; k >= 0; k-- )
        {
            if ( *( value_i + k ) > *( value_j + k ) )
            {
                res = -1;
                break;
            }
            else if ( *( value_i + k ) == *( value_j + k ) )
            {
                res = 0;
            }
            else
            {
                res = 1;
                break;
            }
        }
    } while ( 0 );

    return res;
}

在这里插入图片描述

浮点型与整型不兼容的坑

终于搞定了，负数也能够正常排序了，当我把窗口类型切换为整型时，又又又出幺蛾子了
在这里插入图片描述

在这里插入图片描述

看来可能是整型在对比负数时，字节排列规则和浮点型不太一样，那么解决的办法和上面负数一样，就是根据十六进制辨识出当前数据是整型还是浮点型，找了很久也没有找到合适的方法，float和int所占用的字节大小都是一样的，分辨不出来。

无奈只能做出妥协，在初始化时传入当前窗口的类型是浮点型还是整型，虽然只增加了一个参数，但使得用户程序比较麻烦，类型错误也会导致很多不可预知，不可调试的错误（内存写花了）。若有好的方法欢迎随时和我联系。

最终成果展示：

在这里插入图片描述
在这里插入图片描述

总结

最后终于调试出了我想要的效果，任意类型的容器(有符号整型，无符号整型，浮点型)，任意类型的值（正数，负数，0，浮点数正数，浮点数负数），都能成功的排序。其实排序只是窗口的一个很小很小的算法，但是为了实现排序这个算法，我们实现了操作泛型容器的大部分重要接口，这里就展示下调试最久的比大小：

// 4. 对比两个成员大小，顺序为 i > = < j
static inline int ComparMemberValue( ValueWindowSquential* tmp, int i, int j )
{
    int res = 0;

    bool i_position = GetValuePositive( tmp, i );
    bool j_position = GetValuePositive( tmp, j );

    uint8_t* value_i = ( uint8_t* ) GetMemberAddress( tmp, i );
    uint8_t* value_j = ( uint8_t* ) GetMemberAddress( tmp, j );

    do
    {
        if ( i_position != j_position )
        {
            res = ( i_position == false ) ? 1 : -1;
            break;
        }

        for ( int k = tmp->type_size - 1; k >= 0; k-- )
        {
            if ( *( value_i + k ) > *( value_j + k ) )
            {
                res = -1;
                break;
            }
            else if ( *( value_i + k ) == *( value_j + k ) )
            {
                res = 0;
            }
            else
            {
                res = 1;
                break;
            }
        }
    } while ( 0 );

    if ( !i_position && !j_position )
    {
        res = -res;
    }
    else if ( i_position && j_position && !tmp->is_floating_point )
    {
        res = -res;
    }

    return res;
}

最开始的版本，直接memcmp对比内存，后来遇到了很多很多坑，最终实现了上面的版本，其实只是比大小而已。
现在大家应该对 if(a > b) 有了些自己的理解了把。写编译器的人真的对底层结构太通透了，太强悍了。我在这里也只考虑了相同符号类型之间的比大小，不同符号之间呢？if(uint8_t > float) 该怎么做呢？

有了上述的五个工具函数，理论上就能实现所有的，针对顺序表的任何算法，操作。

先将整个工程开源在github上，以后会继续维护这个项目，实现更多常用的操作方式，实现更多类型，实现用户自定义类型等等。

基于C的泛型窗口容器

奔驰的战猪
关注
专栏目录
C语言实现一个泛型容器
summer的专栏
06-07 868
用C语言实现一个容器，可以装字符串、字符、数字、二进制数据, 其中每一个被装进的数据要附带一个唯一识别码( uid )。 int put_char(List *list, unsigned int uid, char c); int put_string(List *list, unsigned int uid, char *str); int put_integer(List *list,
C语言下的容器及泛型编程
suemiineo
04-20 1万+
1 引言 众所周知，C++语言提供了大名鼎鼎的标准模板库（STL）作为C++语言下的编程利器受到无数青睐，而C语言下并没有提供类似的工具，使得C语言的开发变得尤为困难和专业化。Nesty框架的NCollection容器为C语言提供了一整套标准的、丰富的模板工具，用以弥补C语言在结构化编程上的弱势。之前发表的一篇文章是关于如何在C语言下进行面向对象编程的，主要介绍了NOOC的诸多特性。然而，NOO
C语言通过void*实现的泛型编程
LinxihuilaihoudeMeng的博客
10-31 501
#include <iostream> #include <cstring> void function1(); //实现交换两个元素内容的函数swap演示 void function2(); //在数组array中查找key元素并返回其索引的演示 void swap1(int *ipa, int *ipb); void swap2(void *vp1, void *...
C语言实现泛型编程
weixin_33858485的博客
03-27 294
泛型编程让你编写完全一般化并可重复使用的算法，其效率与针对某特定数据类型而设计的算法相同。在C语言中，可以通过一些手段实现这样的泛型编程。这里介绍一种方法——通过无类型指针void* 看下面的一个实现交换两个元素内容的函数swap，以整型int为例： void swap(int* i1,int* i2){ int temp; temp = *...
void 与泛型计算
weixin_30795127的博客
03-24 120
Void相信很多人在初学C编程时不太理解它是什么意思，例如void main(),main (void) 等等很多书上都有这个词，但是它到底是什么意思呢？ void的字面意思是“无类型”，void *则为“无类型指针”，void *可以指向任何类型的数据。 void几乎只有“注释”和限制程序的作用，定义一个void变量没有意义，不妨试着定义： void a;...
泛化实现
weixin_34395205的博客
11-29 322
1.场景 　　泛接口实现方式主要用于服务器端没有API接口及模型类元的情况，参数及返回值中的所有POJO均用Map表示，通常用于框架集成， 　　比如：实现一个通用的远程服务Mock框架，可通过实现GenericService接口处理所有服务请求。   2.在Java中实现GenericService接口 1 package com.foo; 2 public class MyGenericSer...
纯C泛型容器
03-06
"纯C泛型容器"的设计基于C语言的结构体，这种结构体可以包含一组void指针，用来存储任意类型的元素。在C语言中，void*指针可以指向任何类型的数据，但不能直接进行类型转换或操作。为了正确地使用和操作这些元素，...
如何在C语言中实现简单的泛型编程(一）
热门推荐
the Pensieve
01-26 2万+
题外话               鄙人最近在家里听斯坦福大学的开放课程——《编程范式Programming Paradigms》。 附上veryCD的资源下载地址： http://www.verycd.com/topics/2838268/         这个是英文授课，现在还是没有中文或英文字幕的。就课程来说非常不错。其中Lecture 4中讲到了一种在C语言中不用C++中的te
泛型编程：使用void指针实现通用数据结构
泛型编程则提供了一种解决方案，它允许我们编写可以处理多种类型的通用代码。 ## 介绍泛型编程在实际开发中的重要性 泛型编程在实际开发中具有重要意义。它可以提高代码的可重用性和可扩展性，减少重复代码的编写，...
C语言中的泛型编程与模板
模板是实现泛型编程的一种方式，它允许我们在编译时根据使用场景生成不同的代码实例。 ## 1.2 泛型编程与模板的应用领域 泛型编程与模板在许多领域都有广泛的应用。例如，在数据结构和算法中，我们可以使用模板来...
泛型链表——C语言实现
01-24
使用C语言实现的“泛型链表”，该链表为循环双链表，它的设计参考了C++的STL容器库中的容器list及泛型算法的接口，并使用迭代器来遍历链表。使用时只需要include头文件即可，隐藏了List类型的具体实现。用户并不需要知道链表的具体实现，只需要调用头文件中的接口来进行相应的操作即可。
基于C语言实现泛型编程（抛砖引玉）
su_fei_ma_su的博客
07-01 783
基于C语言实现泛型编程
Void & void Void用在泛型
weixin_30567225的博客
11-27 308
public Void setStr(String key,String value)throws Exception{ RetryTemplate retryTemplate=initRetryTemplate(); retryTemplate.execute(new RetryCallback<Void,Exception>() { int i = 0...
Libevent: 在C语言中实现泛型数据结构
u012342808的博客
03-04 789
窥探C语言中的实现泛型数据结构的技巧
C语言中的泛型编程(void *)
章飞 _906285288的博客
07-22 6071
C语言中的泛型编程(void *)简介：之前有写过关于C++的泛型编程，使用template来实现的，也包括了一些函数模板，类模板的一些概念，那么在纯C的实现中，能不能也有这样的泛型？答案当然是可以的，这个时候就有必要使用所谓的万能指针，因为万能指针可以转换成其他的数据类型指针对象，这个时候就可以实现类型转换啦。提示： 博主：章飞_906285288 博客地址:http://blog.cs
void dispose在c语言里,C语言实现一个泛型栈
weixin_36454202的博客
05-18 889
C语言不能很好的处理泛型数据，不过下面这个泛型栈提供了一种思路，把对数据的操作看作是对一格一格内存的操作，利用Memory头文件里的函数可以做到这一点。可以通过这种思路延伸到队列等其他数据结构中，把对数据的操作抽象为对内存的操作。当然在处理过程当中要处处小心，特别是对指针操作的时候。另外，我写了一个用这个栈解数独的程序，可参考：《穷举法解数独》《更智能的解数独算法，让效率提升5倍！》#includ...
C语言实现泛型队列
huange7的博客
04-13 2016
泛型队列（C语言实现） 队列结构体 typedef struct Aqueue { void *data[MAXQUEUE]; //数据域 int front; int rear; size_t length; //队列长度 //一个节点可存放不同的数据 int type[MAXQUEUE]; //存放进入队列...
六、泛型指针void*
kingsdai的博客
06-14 366
void不可以单独定义变量, 却可以定义无类型的指针, 而且所定义的指针有一个好听的名字, 称为。如果需要使用void*指针，需要重新强转为具体类型，方可使用，不可直接针对void*进行使用。，其含义是void*类型的指针可以接收一切类型变量的地址。void称为无类型，void*称为无类型指针。通过以上两个例子，需要明白函数是如何做到。2、void*指针应用----通用函数。其次，还需要掌握这些常用库函数。
C语言空指针void *(泛型指针)的见解记录
最新发布
weixin_52082065的博客
01-16 453
因为翻译的缘故,void会经常被叫为空,但是假如跟指针组合void *直接翻译成空指针,这样的说法是不严谨不正确的,翻译成泛型指针我觉得更合适,因为void* 不管是什么类型都可以接受,只需要进行强制类型转换.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值