广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > 其他教程 >基于C语言实现泛型编程详解
  • 622

0
分享到

基于C语言实现泛型编程详解

2024-04-02 19:04:59 622人浏览 薄情痞子
摘要

目录心理历程轮子用法大体流程部分源码心理历程 写了一段时间c++后，真心感觉STL里的容器是个好东西。一个容器可以容纳任意类型，容器对外的接口可以操作任意类型的数据，甚至包括自定义类

心理历程

写了一段时间c++后，真心感觉STL里的容器是个好东西。一个容器可以容纳任意类型，容器对外的接口可以操作任意类型的数据，甚至包括自定义类型的数据。这种泛型编程的思想，对于大型项目而言是非常有好处的。

对于C而言，想实现泛型编程并非易事，甚至可以说非常繁琐，一大堆坑。最主要也没有现成的轮子可用。当然也有一些通过宏实现了泛型的基础功能，但是可读性，可调试性太差了。

于是就想自己造一个轮子，实现基于C对窗口（顺序表）的泛化，目标就是实现不同类型下，规范接口的一致性。抛砖引玉。

轮子用法

int main( void )
{
	// 1、创建一个窗口，并初始化它，大小为10，类型为double
    Valuewindowsquential tmp;
    InitValueWindow( &tmp, kValueTypeList[ DOUBLE ], 10 );

    double insert_data = 0;
    for ( int i = 0; i < tmp.max_size; i++ )
    {
    	// 2、填充这个窗口，直到窗口填满
        insert_data = i * 10;
        if ( kWindowAlreadyFull == ValueWindowFixedInsert( &tmp, &insert_data ) )
        {
        	// 3、打印整个窗口
            printf( "start sort \r\n" );
            ShowTheWindow( &tmp );
	
			// 4、整个窗口排序
            ValueWindowSelectSort( &tmp );
	
			// 5、打印排序后的窗口
            printf( "end sort \r\n" );
            ShowTheWindow( &tmp );

            break;
        }
    }

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

打印log如下：

这时想换成创建一个uint8_t类型的串口，只需要改两个地方，这两个地方在C++里也避免不了。

int main( void )
{
    ValueWindowSquential tmp;
    InitValueWindow( &tmp, kValueTypeList[ UINT8 ], 10 );

    uint8_t insert_data = 0;
    for ( int i = 0; i < tmp.max_size; i++ )
    {
        insert_data = ( tmp.max_size - i ) * 1;
        if ( kWindowAlreadyFull == ValueWindowFixedInsert( &tmp, &insert_data ) )
        {
            printf( "start sort \r\n" );
            ShowTheWindow( &tmp );

            ValueWindowSelectSort( &tmp );

            printf( "end sort \r\n" );
            ShowTheWindow( &tmp );

            break;
        }
    }

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

大体流程

1.首先初始化一个空窗口对象，然后调用 InitValueWindow 传入窗口类型，大小，然后初始化它。

2.调用 ValueWindowFixedInsert 往窗口中插入值，直到窗口满后反馈状态。

3.打印整个窗口

4.对窗口排序

5.打印整个窗口

这里的泛型主要通过查表实现了，将希望包含的类型加入表中，然后初始化时传入其类型和大小。

插入数据的时候，需要保证数据类型和窗口类型统一，这算是个局限性了。

窗口被填充完毕后，会有反馈窗口状态，这时可以调用 ShowTheWindow 将原始窗口打印。

在调用 ValueWindowSelectSort 将窗口排序。排序完后再次打印。

可以看到除了初始化的时候，需要设定窗口的类型，这和 std::vector< double > 没什么两样，插入数据时需要调用者确保数据类型与窗口统一。

部分源码

#ifndef __TEST_GENERICS_h
#define __TEST_GENERICS_h

#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <stdlib.h>

#include <assert.h>

typedef signed char   int8_t;
typedef unsigned char uint8_t;

typedef signed short   int16_t;
typedef unsigned short uint16_t;

typedef signed int   int32_t;
typedef unsigned int uint32_t;

typedef enum
{
    UINT8 = 0,
    INT,
    FLOAT,
    DOUBLE,

    ERROR

} TypeName;

const char* kValueTypeList[ ERROR + 1 ] = {

    "uint8_t",

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

    "error",
};

TypeName ChangeStringToEnum( const char* tmp );


typedef struct ValueWindowSquential
{
    char* type;
    void* data;

    uint32_t max_size;

    uint32_t sequence;

} ValueWindowSquential;


void InitValueWindow( ValueWindowSquential* tmp, const char* type, uint32_t max_size );


void ResetValueWindow( ValueWindowSquential* tmp );

typedef enum
{
    kWindowIsNotFull = ( 0 ),
    kWindowIsSliding,

    kWindowCanNotInsert,
    kWindowInputFail,

} SlideWindowState;

SlideWindowState ValueWindowSlideInsert( ValueWindowSquential* tmp, void* data );

typedef enum
{
    kWindowNotFull = ( 0 ),
    kWindowAlreadyFull,

    kFixWindowCanNotInsert,
    kFixWindowInputFail,

} FixedWindowState;

FixedWindowState ValueWindowFixedInsert( ValueWindowSquential* tmp, void* data );


void ShowTheWindow( ValueWindowSquential* tmp );

#endif // __TEST_GENERICS_h


#include "test_generics.h"

#include "generics_impl.h"


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 );
        }
        break;

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

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

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

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

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

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

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

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

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

    switch ( ChangeStringToEnum( tmp->type ) )
    {
        case UINT8: {
            uint8_t* tmp_buffer = ( uint8_t* ) tmp->data;
            for ( int i = 1; i < tmp->max_size; i++ )
            {
                tmp_buffer[ i - 1 ] = tmp_buffer[ i ];
            }
            uint8_t* res                    = ( uint8_t* ) data;
            tmp_buffer[ tmp->max_size - 1 ] = *res;
        }
        break;

        case INT: {
            int* tmp_buffer = ( int* ) tmp->data;
            for ( int i = 1; i < tmp->max_size; i++ )
            {
                tmp_buffer[ i - 1 ] = tmp_buffer[ i ];
            }
            int* res                        = ( int* ) data;
            tmp_buffer[ tmp->max_size - 1 ] = *res;
        }
        break;

        case FLOAT: {
            float* tmp_buffer = ( float* ) tmp->data;
            for ( int i = 1; i < tmp->max_size; i++ )
            {
                tmp_buffer[ i - 1 ] = tmp_buffer[ i ];
            }
            float* res                      = ( float* ) data;
            tmp_buffer[ tmp->max_size - 1 ] = *res;
        }
        break;

        case DOUBLE: {
            double* tmp_buffer = ( double* ) tmp->data;
            for ( int i = 1; i < tmp->max_size; i++ )
            {
                tmp_buffer[ i - 1 ] = tmp_buffer[ i ];
            }
            double* res                     = ( double* ) data;
            tmp_buffer[ tmp->max_size - 1 ] = *res;
        }
        break;

        default: {
            printf( "error tmp->type input !!!" );
            assert( 0 );
        }
        break;
    }
    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;

    switch ( ChangeStringToEnum( tmp->type ) )
    {
        case UINT8: {
            uint8_t* tmp_buffer = ( uint8_t* ) tmp->data;
            uint8_t* res        = ( uint8_t* ) data;

            tmp_buffer[ tmp->sequence ] = *res;
        }
        break;

        case INT: {
            int* tmp_buffer = ( int* ) tmp->data;
            int* res        = ( int* ) data;

            tmp_buffer[ tmp->sequence ] = *res;
        }
        break;

        case FLOAT: {
            float* tmp_buffer = ( float* ) tmp->data;
            float* res        = ( float* ) data;

            tmp_buffer[ tmp->sequence ] = *res;
        }
        break;

        case DOUBLE: {
            double* tmp_buffer = ( double* ) tmp->data;
            double* res        = ( double* ) data;

            tmp_buffer[ tmp->sequence ] = *res;
        }
        break;

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

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

// 打印窗口内全部值
void ShowTheWindow( ValueWindowSquential* tmp )
{
    // printf("current_type:{%d}", ChangeStringToEnum(tmp->type));
    switch ( ChangeStringToEnum( tmp->type ) )
    {
        case UINT8: {
            uint8_t* msg = ( uint8_t* ) tmp->data;
            for ( int i = 0; i < tmp->max_size; ++i )
            {
                printf( "i : {%d} , %d \r\n", i, msg[ i ] );
            }
        }
        break;

        case INT: {
            int* msg = ( int* ) tmp->data;
            for ( int i = 0; i < tmp->max_size; ++i )
            {
                printf( "i : {%d} , %d \r\n", i, msg[ i ] );
            }
        }
        break;

        case FLOAT: {
            float* msg = ( float* ) tmp->data;
            for ( int i = 0; i < tmp->max_size; ++i )
            {
                printf( "i : {%d} , %f \r\n", i, msg[ i ] );
            }
        }
        break;

        case DOUBLE: {
            double* msg = ( double* ) tmp->data;
            for ( int i = 0; i < tmp->max_size; ++i )
            {
                printf( "i : {%d} , %f \r\n", i, msg[ i ] );
            }
        }
        break;

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

int main( void )
{
    ValueWindowSquential tmp;
    InitValueWindow( &tmp, kValueTypeList[ DOUBLE ], 10 );

    double insert_data = 0;
    for ( int i = 0; i < tmp.max_size; i++ )
    {
        insert_data = ( tmp.max_size - i ) * 10;
        if ( kWindowAlreadyFull == ValueWindowFixedInsert( &tmp, &insert_data ) )
        {
            printf( "start sort \r\n" );
            ShowTheWindow( &tmp );

            ValueWindowSelectSort( &tmp );

            printf( "end sort \r\n" );
            ShowTheWindow( &tmp );

            break;
        }
    }
    ResetValueWindow(&tmp);

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

这是最开始的一版源码，基本的思路是基于 void* 实现对窗口的泛化，把窗口的地址，大小，类型 在初始化时设定好，以后所有的结构便基于这些信息，实现接口一致性。

目前实现了两种窗口类型, ValueWindowSlideInsert (滑动窗) 和 ValueWindowFixedInsert(固定窗) 。 两者不同之处只是插入数据时的处理不同。滑动窗遵循FIFO模型，即先入先出，窗口状态有未满和开始滑动，一般开始滑动后再对窗口进行操作。

固定窗有未满和已满两种状态，已满后会清空窗口，重新开始填充，这也是两种常见的窗口模型。

在STL里，当有一些底层数据结构去存储数据时，要有一些容器的方法（算法），比如排序等，这里先实现了一些基础的泛型算法接口：

#ifndef GENERICS_IMPL_H
#define GENERICS_IMPL_H

#include <stdbool.h>

#include "test_generics.h"




static void swap( ValueWindowSquential* tmp, uint32_t i, uint32_t j )
{
    assert( tmp != NULL );
    // assert( i > tmp->max_size || j > tmp->max_size );
    // assert( i >= tmp->max_size || j >= tmp->max_size );

    switch ( ChangeStringToEnum( tmp->type ) )
    {
        case UINT8: {
            uint8_t* tmp_buffer = ( uint8_t* ) tmp->data;
            uint8_t  res        = tmp_buffer[ i ];

            tmp_buffer[ i ] = tmp_buffer[ j ];
            tmp_buffer[ j ] = res;
        }
        break;

        case INT: {
            int* tmp_buffer = ( int* ) tmp->data;
            int  res        = tmp_buffer[ i ];

            tmp_buffer[ i ] = tmp_buffer[ j ];
            tmp_buffer[ j ] = res;
        }
        break;

        case FLOAT: {
            float* tmp_buffer = ( float* ) tmp->data;
            float  res        = tmp_buffer[ i ];

            tmp_buffer[ i ] = tmp_buffer[ j ];
            tmp_buffer[ j ] = res;
        }
        break;

        case DOUBLE: {
            double* tmp_buffer = ( double* ) tmp->data;
            double  res        = tmp_buffer[ i ];

            tmp_buffer[ i ] = tmp_buffer[ j ];
            tmp_buffer[ j ] = res;
        }
        break;

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

static inline void ValueWindowBubbleSort( ValueWindowSquential* tmp )
{
    switch ( ChangeStringToEnum( tmp->type ) )
    {
        case UINT8: {
            uint8_t* tmp_buffer = ( uint8_t* ) tmp->data;

            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 ( tmp_buffer[ j - 1 ] > tmp_buffer[ j ] )
                    {
                        swap( tmp, j - 1, j );
                        is_end_loop = true;
                    }
                }
            }
        }
        break;

        case INT: {
            int* tmp_buffer = ( int* ) tmp->data;

            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 ( tmp_buffer[ j - 1 ] > tmp_buffer[ j ] )
                    {
                        swap( tmp, j - 1, j );
                        is_end_loop = true;
                    }
                }
            }
        }
        break;

        case FLOAT: {
            float* tmp_buffer = ( float* ) tmp->data;

            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 ( tmp_buffer[ j - 1 ] > tmp_buffer[ j ] )
                    {
                        swap( tmp, j - 1, j );
                        is_end_loop = true;
                    }
                }
            }
        }
        break;

        case DOUBLE: {
            double* tmp_buffer = ( double* ) tmp->data;

            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 ( tmp_buffer[ j - 1 ] > tmp_buffer[ j ] )
                    {
                        swap( tmp, j - 1, j );
                        is_end_loop = true;
                    }
                }
            }
        }
        break;

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

static inline void ValueWindowSelectSort( ValueWindowSquential* tmp )
{
    switch ( ChangeStringToEnum( tmp->type ) )
    {
        case UINT8: {
            uint8_t* tmp_buffer = ( uint8_t* ) tmp->data;

            int tmp_data = 0;
            for ( int i = 0; i < tmp->max_size; i++ )
            {
                tmp_data = i;
                for ( int j = i; j < tmp->max_size; j++ )
                {
                    if ( tmp_buffer[ tmp_data ] > tmp_buffer[ j ] )
                    {
                        tmp_data = j;
                    }
                }
                if ( tmp_data != i )
                {
                    swap( tmp, i, tmp_data );
                }
            }
        }
        break;

        case INT: {
            int* tmp_buffer = ( int* ) tmp->data;

            int tmp_data = 0;
            for ( int i = 0; i < tmp->max_size; i++ )
            {
                tmp_data = i;
                for ( int j = i; j < tmp->max_size; j++ )
                {
                    if ( tmp_buffer[ tmp_data ] > tmp_buffer[ j ] )
                    {
                        tmp_data = j;
                    }
                }
                if ( tmp_data != i )
                {
                    swap( tmp, i, tmp_data );
                }
            }
        }
        break;

        case FLOAT: {
            float* tmp_buffer = ( float* ) tmp->data;

            int tmp_data = 0;
            for ( int i = 0; i < tmp->max_size; i++ )
            {
                tmp_data = i;
                for ( int j = i; j < tmp->max_size; j++ )
                {
                    if ( tmp_buffer[ tmp_data ] > tmp_buffer[ j ] )
                    {
                        tmp_data = j;
                    }
                }
                if ( tmp_data != i )
                {
                    swap( tmp, i, tmp_data );
                }
            }
        }
        break;

        case DOUBLE: {
            double* tmp_buffer = ( double* ) tmp->data;

            int tmp_data = 0;
            for ( int i = 0; i < tmp->max_size; i++ )
            {
                tmp_data = i;
                for ( int j = i; j < tmp->max_size; j++ )
                {
                    if ( tmp_buffer[ tmp_data ] > tmp_buffer[ j ] )
                    {
                        tmp_data = j;
                    }
                }
                if ( tmp_data != i )
                {
                    swap( tmp, i, tmp_data );
                }
            }
        }
        break;

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

static inline void ValueWindowInsertSort( ValueWindowSquential* tmp )
{
    switch ( ChangeStringToEnum( tmp->type ) )
    {
        case UINT8: {
            uint8_t* tmp_buffer = ( uint8_t* ) tmp->data;

            uint8_t tmp_data = 0;
            int     j        = 0;
            for ( int i = 1; i < tmp->max_size; i++ )
            {
                if ( tmp_buffer[ i ] < tmp_buffer[ i - 1 ] )
                {
                    tmp_data = tmp_buffer[ i ];
                    // TAG : 数据整体向后迁移,寻找数值更大的成员
                    for ( j = i - 1; tmp_buffer[ j ] > tmp_data && j >= 0; j-- )
                    {
                        tmp_buffer[ j + 1 ] = tmp_buffer[ j ];
                    }
                    tmp_buffer[ j + 1 ] = tmp_data;
                }
            }
        }
        break;

        case INT: {
            int* tmp_buffer = ( int* ) tmp->data;

            int tmp_data = 0;
            int j        = 0;
            for ( int i = 1; i < tmp->max_size; i++ )
            {
                if ( tmp_buffer[ i ] < tmp_buffer[ i - 1 ] )
                {
                    tmp_data = tmp_buffer[ i ];
                    // TAG : 数据整体向后迁移,寻找数值更大的成员
                    for ( j = i - 1; tmp_buffer[ j ] > tmp_data && j >= 0; j-- )
                    {
                        tmp_buffer[ j + 1 ] = tmp_buffer[ j ];
                    }
                    tmp_buffer[ j + 1 ] = tmp_data;
                }
            }
        }
        break;

        case FLOAT: {
            float* tmp_buffer = ( float* ) tmp->data;

            float tmp_data = 0;
            int   j        = 0;
            for ( int i = 1; i < tmp->max_size; i++ )
            {
                if ( tmp_buffer[ i ] < tmp_buffer[ i - 1 ] )
                {
                    tmp_data = tmp_buffer[ i ];
                    // TAG : 数据整体向后迁移,寻找数值更大的成员
                    for ( j = i - 1; tmp_buffer[ j ] > tmp_data && j >= 0; j-- )
                    {
                        tmp_buffer[ j + 1 ] = tmp_buffer[ j ];
                    }
                    tmp_buffer[ j + 1 ] = tmp_data;
                }
            }
        }
        break;

        case DOUBLE: {
            double* tmp_buffer = ( double* ) tmp->data;

            double tmp_data = 0;
            int    j        = 0;
            for ( int i = 1; i < tmp->max_size; i++ )
            {
                if ( tmp_buffer[ i ] < tmp_buffer[ i - 1 ] )
                {
                    tmp_data = tmp_buffer[ i ];
                    // TAG : 数据整体向后迁移,寻找数值更大的成员
                    for ( j = i - 1; tmp_buffer[ j ] > tmp_data && j >= 0; j-- )
                    {
                        tmp_buffer[ j + 1 ] = tmp_buffer[ j ];
                    }
                    tmp_buffer[ j + 1 ] = tmp_data;
                }
            }
        }
        break;

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

以上就是基于C语言实现泛型编程详解的详细内容，更多关于C语言 泛型编程的资料请关注编程网其它相关文章！

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 基于C语言实现泛型编程详解

本文链接: https://www.lsjlt.com/news/153565.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • 基于C语言实现泛型编程详解
    目录心理历程轮子用法大体流程部分源码心理历程 写了一段时间C++后，真心感觉STL里的容器是个好东西。一个容器可以容纳任意类型，容器对外的接口可以操作任意类型的数据，甚至包括自定义类...
    99+
    2022-11-13
  • C语言中如何实现泛型编程
    今天小编给大家分享一下C语言中如何实现泛型编程的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。泛型编程(generic &nb...
    99+
    2023-06-17
  • C语言中怎么实现泛型编程
    这篇文章给大家介绍C语言中怎么实现泛型编程，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。泛型编程(generic  programming)是程序设计语言的一种风格或范式。泛型允许程序员在强类型程序设计语言中...
    99+
    2023-06-15
  • C++泛型编程基本概念详解
    目录1.什么是泛型编程？2.函数模板(1)函数模板概念(2)函数模板格式(3)函数模板的原理(4)函数模板的实例化(5)模板参数的匹配原则3.类模板(1)类模板的定义格式(2)类模板...
    99+
    2022-11-12
  • 基于C++泛型编程职工管理系统
    目录一、泛型编程思想二、单链表是什么1.图示2.链表的节点结构【节点类】3.链表类三、泛型编程核心1.实现数据类2.实现链表类四、运行截图1.主菜单2.查看信息3.更换数据类型4.再...
    99+
    2022-11-13
  • C语言的模板与泛型编程你了解吗
    目录模板与泛型编程浅谈摘要(Effective C++)：模板与泛型编程简单介绍函数模板模板编译类模板为什么我们需要模板特例化？总结模板与泛型编程浅谈 摘要(Effective C+...
    99+
    2022-11-13
  • C语言的模板与泛型编程是什么
    本篇内容主要讲解“C语言的模板与泛型编程是什么”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“C语言的模板与泛型编程是什么”吧!模板与泛型编程浅谈摘要(Effective C++)：C++temp...
    99+
    2023-06-29
  • 基于C语言实现2048游戏
    本文实例为大家分享了C语言实现2048游戏的具体代码，供大家参考，具体内容如下 #include <stdio.h> #include <stdlib.h>...
    99+
    2022-11-12
  • 详解C语言的基本数据类型
    目录1、C语言基本数据类型2、计算机中的单位3、各数据类型的大小及字取值大小总结1、C语言基本数据类型 2、计算机中的单位 3、各数据类型的大小及字取值大小 对于short i...
    99+
    2022-11-12
  • 详解C语言基础的类型转换
    目录类型转换隐式类型转换强制类型转换总结 类型转换 数据有不同的类型，不同类型数据之间进行混合运算时必然涉及到类型的转换问题。转换包括隐式类型转换和强制类型转换。 类型转换的原则：...
    99+
    2022-11-12
  • 一文详解C++模板和泛型编程
    目录模板的定义模板的实例化类模板模板元编程总结模板的定义 C++中的模板和泛型编程是非常重要的概念。模板是一种将数据类型作为参数的通用程序设计方法。它们允许开发人员编写可以处理各种数...
    99+
    2023-05-20
    C++模板泛型编程 C++ 泛型编程
  • 基于C#实现语音识别功能详解
    在.NET4.0中，我可以借助System.Speech组件让电脑来识别我们的声音。 以上，当我说"name"，显示"Darren"，我说&...
    99+
    2022-11-13
  • 基于C语言实现http下载器
    目录功能思路缺陷代码C语言实现http的下载器。 例：做OTA升级功能时，我们能直接拿到的往往只是升级包的链接，需要我们自己去下载，这时候就需要用到http下载器。 这里分享一个： ...
    99+
    2022-12-28
    C语言http下载器 C语言http下载 C语言 下载器
  • C语言基于EasyX实现贪吃蛇
    本文实例为大家分享了C语言基于EasyX实现贪吃蛇的具体代码，供大家参考，具体内容如下 成品展示： 实现思路： 贪吃蛇的实现思路并不复杂，由于我们需要将数据展示在图形窗口上，因此就...
    99+
    2022-11-13
  • C语言基于graphics.h实现圣诞树
    头文件 icon.h： #pragma once #ifndef _ICON_H_ #define _ICON_H_ #include<graphics.h> #...
    99+
    2022-11-12
  • C#高级静态语言效率利器之泛型详解
    目录引入类型约束子类泛型常用的泛型数据结构泛型委托引入 所谓泛型，就是创建一个函数，对所有数据类型都生效。最常见的例子就是运算符，毕竟1+1=2，1.0+1.0=2.0，足以看出+是...
    99+
    2023-02-27
    C#泛型使用 C#泛型
  • C++实现支持泛型的LFU详解
    首先定义LFU存储数据节点ListNode的结构, 此结构支持键K和值V的模板，为了在有序元素中实现比较（严格小于），这里需要重载小于号，如果此数据的使用频次最少，则小于结果为tru...
    99+
    2022-11-12
  • 详解Go语言中泛型的实现原理与使用
    目录前言问题解决方法类型约束重获类型安全泛型使用场景性能虚拟方法表单态化Go 的实现结论前言 原文：A gentle introduction to generics in G...
    99+
    2022-06-07
    详解go语言 GO 泛型 go语言
  • C语言基础指针详解教程
    目录1.1：概述1.1.1：内存1.1.2：内存1.1.3：指针和指针变量1.2：指针基础知识1.2.1：指针变量的定义和使用1.2.2：通过指针间接修改变量的值1.2.3：指针的大...
    99+
    2022-11-12
  • C++编程语言实现单链表详情
    目录一、单链表简单介绍二、下面我们先实现单链表的初始化。 三、实现单链表的插入与删除数据一、单链表简单介绍 首先，我们再回顾一下线性表的两种存储方式——顺序存储与链式存储 上图左边...
    99+
    2022-11-12
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作