精华内容
下载资源
问答
  • Python从可长度数组刷新Pyplot线
    2021-01-29 15:27:12

    我肯定有人问过这个问题,但我一直很难找到一个简明的答案,在搜索中起作用。一些好的答案似乎取决于提前计算数组的最终大小。看起来这应该很简单,而且我是个新手,所以我可能只是搜索了错误的术语。。。在

    我的问题是:

    当数组长度未知且随时间变化时,如何让PyPlot刷新源于numpy数组的现有行的数据?

    我现在的代码如下#Initial Setup

    changing_dataset = np.array(1) #initialize with a single blank y-value

    plt.close('all') #clear all the priors

    plt.ion()

    f, axarr = plt.subplots(3,2) #setup a 3x2 plot ...only 1 shown below

    axarr[0,0].set_title('My Plot')

    line1, = axarr[0,0].plot(changing_dataset)

    plt.show

    ... some code which appends new data to changing_dataset is omitted here...

    我只想这么做:

    ^{pr2}$

    为了更新初始绘图中的行,现在将基于数组“changing_dataset”中包含的新的、更大的数据集。在

    但这会产生一个错误

    值错误:形状不匹配:对象不能广播到单个形状

    如何避开似乎需要数组为静态大小的要求?我宁愿不需要重新命名和从头开始构建绘图-因为唯一需要更改的是线条(可能还会自动重新缩放轴)

    更多相关内容
  • java变长参数,是怎样变长的?

    千次阅读 2018-07-29 13:20:41
    java方法支持变长参数。这样能够极大地简化我们的编程。我们看这样一段代码: public class Args { public static void main(String[] args) { String two = stringConcat("A", "B"); ...

    java方法支持变长参数。这样能够极大地简化我们的编程。我们看这样一段代码:

    public class Args {
        public static void main(String[] args) {
            String two = stringConcat("A", "B");
            String three = stringConcat("A", "B", "C");
        }
    
        public static String stringConcat(String... objs) {
             String sum = "";
             for (String s : objs) {
                 sum += s;
             }//for
             return sum;
        }
    }

    在JDK1.8.0_151的环境下,我们利用javac编译上面的源代码,得到Args.class字节码文件。

    利用javap反编译了Args.class字节码文件,截取StringConcat方法的反编译结果。如图:

    为什么会出现,arraylength指令,难道,变长参数和数组有什么关系?大胆假设,小心求证。

    我们借助于IDEA, 反编译Args.class字节码文件,以得到更直观的结果:

     请注意,我用红笔画出的部分。因为它证明了我的猜想,的确,变长参数是通过数组来实现的。

    再用jd-gui来看看反编译结果。

    看到标出重点的部分,jd-gui的反编译结果再次验证了我们的猜想。

    我们改写文章开头的代码,改成如下形式:

    public class Args {
        public static void main(String[] args) {
            String two = stringConcat("A", "B");
            String three = stringConcat("A", "B", "C");
            System.out.println(two);
            System.out.println(three);
        }
    
        public static String stringConcat(String... objs) {
             String[] arr = objs;
             int length = arr.length;
             String sum = "";
             for (int i = 0; i < length; i++) {
                 sum += arr[i];
             }//for
             return sum;
        }
    }

    同样,在JDK1.8.0_151环境下,我们尝试编译并运行这段代码,看它是否可以正常工作。

    如图:

    程序正常通过编译,并成功运行。 我们用【javap -c Args.class】反编译看看StringConcat方法:

    arraylength指令出现了。用IDEA反编译结果如下:

    除了那两行输出,其余是不是和前面的IDEA反编译结果一模一样。这也证明了我们的猜想。

    【结论】:java的变长参数,是java的一颗语法糖,其本质上是用数组形式来实现。

    展开全文
  • C语言的变长参数在平时做开发时很少会在自己设计的接口中用到,但我们最常用的接口printf就是使用的变长参数接口,在感受到printf强大的魅力的同时,是否想挖据一下到底printf是如何实现的呢?这里我们一起来挖掘...
  • Python: 浅析列表的变长变短

    千次阅读 2020-12-06 05:09:25
    变长的关键 初始化过程是这样还可以理解,如果运行中还这样的话,那就有点说不过去了。 试想下,在文章开头用 append 的例子中,如果每 append 一个元素就申请一次内存,那么list 可能要被吐槽到怀疑人生了, 所以...

    前言

    Python 的列表(list)是一个非常灵活的数组,可以随意调整长度。正是因为这种便利,使得我们会情不自禁地去修改数组以满足我们的需求,其中相比于insert, pop 等等而言, append 用法更常见。

    有像这样使用:

    >>> test = []

    >>> test.append(1)

    >>> test.append({2})

    >>> test.append([3])

    >>> print test

    # 输出

    [1, set([2]), [3]]

    也有像这样使用的:

    test = []

    for i in range(4):

    test.append(i)

    print test

    # 输出

    [0, 1, 2, 3]

    这样用很开心,也很满足。

    但其实只要遇到能够动态修改数据长度场景,我们都应该马上反应过来一点,那就是内存管理的问题。

    如果运行效率和便捷性同时满足的话,那简直就是大大的福音呀。

    然而,上帝为你开启一扇窗的同时肯定也已经关上了一扇门了!

    吝啬的初始化

    深受预分配知识的熏陶,我们也是觉得 list 在初始化是有分配一定的长度的,要不然每次都申请内存那得多 ”low“ 啊。

    然后实际上 list 真的就是这么 ”low“:

    import sys

    test = []

    test_1 = [1]

    print sys.getsizeof(test)

    print sys.getsizeof(test_1) - sys.getsizeof(test)

    # 输出

    72 # 空列表内存大小,也是 list 对象的总大小

    8 # 代表增加一个成员,list 增加的大小 ( 此大小为对象指针的长度 )

    我们的猜测是,list 在定义之后,会预先分配好一个一定大小的池用来塞数据,以避免动不动就申请内存。

    但是在上面的实验看出,一个成员的列表,比一个空列表,长度仅仅只是大了 8 字节(对象指针的大小),如果真的存在这样一个预分配的池,那么在预分配个数之内添加成员,两者的内存大小应该是保持不变才对。

    所以可以猜测这块 list 应该是没有这样的一个预分配内存池。这里需要来个实锤

    PyObject *

    PyList_New(Py_ssize_t size)

    {

    PyListObject *op;

    size_t nbytes;

    if (size < 0) {

    PyErr_BadInternalCall();

    return NULL;

    }

    /* Check for overflow without an actual overflow,

    * which can cause compiler to optimise out */

    if ((size_t)size > PY_SIZE_MAX / sizeof(PyObject *))

    return PyErr_NoMemory();

    // list对象指针的缓存

    if (numfree) {

    numfree--;

    op = free_list[numfree];

    _Py_NewReference((PyObject *)op);

    } else {

    op = PyObject_GC_New(PyListObject, &PyList_Type);

    if (op == NULL)

    return NULL;

    }

    // list 成员的内存申请

    nbytes = size * sizeof(PyObject *);

    if (size <= 0)

    op->ob_item = NULL;

    else {

    op->ob_item = (PyObject **) PyMem_MALLOC(nbytes);

    if (op->ob_item == NULL) {

    Py_DECREF(op);

    return PyErr_NoMemory();

    }

    memset(op->ob_item, 0, nbytes);

    }

    Py_SIZE(op) = size;

    op->allocated = size;

    _PyObject_GC_TRACK(op);

    return (PyObject *) op;

    }

    当我们在执行 test = [1] 时,实际上只做了两件事:

    根据成员的数目,构建相应长度的空列表;(上述代码)

    一个个将这些成员塞进去;

    可能有童鞋会觉得,在塞成员的那一步,说不定会触发什么机制使它变大?

    很可惜,因为初始化用的方法是 PyList_SET_ITEM, 所以这里是木有的触发什么机制,只是简单的数组成员赋值而已:

    #define PyList_SET_ITEM(op, i, v) (((PyListObject *)(op))->ob_item[i] = (v))

    所以整个 list 的初始化,还真的就是木有预分配的内存池,直接按需申请,一个萝卜一个坑,实在得狠;

    可变长的关键

    初始化过程是这样还可以理解,如果运行中还这样的话,那就有点说不过去了。

    试想下,在文章开头用 append 的例子中,如果每 append 一个元素就申请一次内存,那么list 可能要被吐槽到怀疑人生了, 所以很明显,在对于内存的申请,它还是有自己的套路的。

    在 list 里面,不管是 insert 、pop 还是 append,都会遇到 list_resize,故名思义,这个函数就是用来调整 list 对象的内存占用的。

    static int

    list_resize(PyListObject *self, Py_ssize_t newsize)

    {

    PyObject **items;

    size_t new_allocated;

    Py_ssize_t allocated = self->allocated;

    /* Bypass realloc() when a previous overallocation is large enough

    to accommodate the newsize. If the newsize falls lower than half

    the allocated size, then proceed with the realloc() to shrink the list.

    */

    if (allocated >= newsize && newsize >= (allocated >> 1)) {

    assert(self->ob_item != NULL || newsize == 0);

    Py_SIZE(self) = newsize;

    return 0;

    }

    /* This over-allocates proportional to the list size, making room

    * for additional growth. The over-allocation is mild, but is

    * enough to give linear-time amortized behavior over a long

    * sequence of appends() in the presence of a poorly-performing

    * system realloc().

    * The growth pattern is: 0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...

    */

    # 确定新扩展之后的占坑数

    new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6);

    /* check for integer overflow */

    if (new_allocated > PY_SIZE_MAX - newsize) {

    PyErr_NoMemory();

    return -1;

    } else {

    new_allocated += newsize;

    }

    if (newsize == 0)

    new_allocated = 0;

    # 申请内存

    items = self->ob_item;

    if (new_allocated <= (PY_SIZE_MAX / sizeof(PyObject *)))

    PyMem_RESIZE(items, PyObject *, new_allocated);

    else

    items = NULL;

    if (items == NULL) {

    PyErr_NoMemory();

    return -1;

    }

    self->ob_item = items;

    Py_SIZE(self) = newsize;

    self->allocated = new_allocated;

    return 0;

    }

    在上面的代码中,频繁看到两个名词:newsize 和 new_allocated, 这里需要解释下,newsize 并不是 增加/减少 的个数,而是 增加/减少 之后的成员总数目。比方说:

    a = [1, 2, 3]

    a.append(1)

    上面的 append 触发list_resize 时, newsize 是 3 + 1, 而不是 1;这边比较重要,因为在 pop 这类减少列表成员时候,就是传入缩减后的总数目。

    在 list 的结构定义中,关于长度的定义有两个,分别是 ob_size(实际的成员数),allocated(总成员数)

    它们之间的关系就是:

    0 <= ob_size <= allocated

    len(list) == ob_size

    所以 new_allocated 就很好理解了,这个就是新的总坑数。

    当名词含义理解得差不多时,我们就能顺藤摸瓜知道一个列表在list_resize 之后,大小会变成怎样?

    方法其实从上面注释和代码都说得很明白了,这里再简单整理下:

    先确定一个基数:new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6);

    判断下 new_allocated + newsize 有没有超过 PY_SIZE_MAX, 如果超过了,直接报错;

    最终确定新的总坑数是:new_allocated + newsize, 如果 newsize 是 0, 那么总坑数直接为 0 ;

    下面演示下:

    #coding: utf8

    import sys

    test = []

    raw_size = sys.getsizeof(test)

    test.append(1)

    print "1 次 append 减去空列表的内存大小:%s " % (sys.getsizeof(test) - raw_size)

    test.append(1)

    print "2 次 append 减去空列表的内存大小:%s " % (sys.getsizeof(test) - raw_size)

    test.append(1)

    print "3 次 append 减去空列表的内存大小:%s " % (sys.getsizeof(test) - raw_size)

    test.append(1)

    print "4 次 append 减去空列表的内存大小:%s " % (sys.getsizeof(test) - raw_size)

    test.append(1)

    print "5 次 append 减去空列表的内存大小:%s " % (sys.getsizeof(test) - raw_size)

    test.append(1)

    print "6 次 append 减去空列表的内存大小:%s " % (sys.getsizeof(test) - raw_size)

    # 输出结果

    1 次 append 减去空列表的内存大小:32

    2 次 append 减去空列表的内存大小:32

    3 次 append 减去空列表的内存大小:32

    4 次 append 减去空列表的内存大小:32

    5 次 append 减去空列表的内存大小:64

    6 次 append 减去空列表的内存大小:64

    开始简单的代入法一步步算:

    其中:

    new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6) + newsize (因为下面的 newsize > 0)

    当原allocated >= newsize 并且 newsize >= 原allocated / 2 时,不改变 allocated 不申请内存直接返回

    第 n 次 append

    列表原长度

    新增成员数

    原 allocated

    newsize

    new_allocated

    1

    0

    1

    0

    0 + 1 = 1

    3 + 1 = 4

    2

    1

    1

    4

    1 + 1 = 2

    无需改变

    3

    2

    1

    4

    2 + 1 = 3

    无需改变

    4

    3

    1

    4

    3 + 1 = 4

    无需改变

    5

    4

    1

    4

    4 + 1 = 5

    3 + 5 = 8

    6

    5

    1

    8

    5 + 1 = 6

    无需改变

    通过上面的表格,应该比较清楚看到什么时候会触发改变 allocated,并且当触发时它们是如何计算的。为什么我们需要这样关注 allocated?理由很简单,因为这个值决定了整个 list 的动态内存的占用大小;

    扩容是这样,缩容也是照猫画虎。反正都是算出新的 allocated, 然后由 PyMem_RESIZE 来处理。

    #define PyMem_REALLOC(p, n) ((size_t)(n) > (size_t)PY_SSIZE_T_MAX ? NULL \

    : realloc((p), (n) ? (n) : 1))

    #define PyMem_RESIZE(p, type, n) \

    ( (p) = ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \

    (type *) PyMem_REALLOC((p), (n) * sizeof(type))

    基本上,就是判断是否超过最大数,否则的话就是和C realloc函数近似了,以下摘抄了一段关于C realloc函数的描述:

    多说几句

    综上所述,在一些明确列表成员或者简单处理再塞入列表的情况下,我们不应该再用下面的方式:

    test = []

    for i in xrange(4):

    test.append(i)

    print test

    而是应该用列表推导式:test = [i for i in xrange(4)]。

    为什么推荐列表推导呢?显而易见的效果就有:

    简练、清晰;

    用多少就申请多少,不会因为 append 触发 PyMem_RESIZE 申请过多内存;容易造成内存浪费;

    相比 for i in xxx,列表推导方式直接增加元素,少了一些函数调用,如:SETUP_LOOP、CALL_FUNCTION 等;

    但是上面的推荐肯定也是在某些前提条件下才合适咯:

    真的只是为了得到一个列表;

    循环体内逻辑简单,没有太复杂的处理、判断、调用等等;

    PS: 切记勿为了使用列表推导而使用,合理使用才是科学之道;

    欢迎各位大神指点交流, QQ讨论群: 258498217

    展开全文
  • C语言怎么实现可长度字符串关注:149答案:3手机版解决时间 2021-02-09 17:22提问者北墓南笙2021-02-09 04:15比如C# 写了个配置文件 不管多都声明一个string变量用StreamReader下的方法载入进入貌似C语言没这样的...

    C语言怎么实现可变长度字符串

    关注:149  答案:3  手机版

    解决时间 2021-02-09 17:22

    提问者北墓南笙

    2021-02-09 04:15

    比如C# 写了个配置文件 不管多长都声明一个string变量用StreamReader下的方法载入进入

    貌似C语言没这样的懒方法 那该怎么做呢

    最佳答案

    二级知识专家一个狠有粪量的人

    2021-02-09 05:01

    char * p = (char*)malloc(sizeof(char)*n)别忘了free

    C++和C#的string类型在最低层实际也是利用类似方法去做的

    另外有一种

    char str[SIZE_MAX]也有人喜欢用

    realloc函数

    只是不太推荐,主要原因是以前系统上这个函数操作会出问题,因为内存的原因

    全部回答

    1楼没仙气的仙女

    2021-02-09 05:30

    C语言实现可变长度字符串,主要依靠realloc函数实现,主要代码如下,

    //程序功能,判断插入字符长度len,若大于预设大小n,调整字符串数组大小,实现动态处理数组大小。

    #include

    #include

    #include

    int main(int argc, char *argv[])

    {

    char * pstr = NULL;

    int n=10;//字符串初始大小

    char str[100];//待插入字符串

    int len=0;//待插入字符串长度

    pstr = (char*)malloc(sizeof(char)*n);//申请sizeof(char)*n个大小的内存空间

    if (pstr==NULL)

    {

    printf("内存申请出错,程序退出!\n");

    exit(1);

    }

    memset(pstr,'\0',sizeof(char)*n);//初始化内存空间

    printf("输入待插入字符串:\n");

    gets(str);

    len=strlen(str)+1;

    printf("内存申请出错,程序退出!%d\n",len);

    if(len>n)//字符串长度大于初始大小n,重新申请内存空间

    pstr=(char *)realloc(pstr,sizeof(char)*len);//重新申请内存空间

    strcat(pstr,str);//将插入字符串连接给pstr

    puts(pstr);

    if (pstr==NULL)//清理申请内存

    {

    free(pstr);

    pstr=NULL;

    }

    return 0;

    }

    void *realloc( void *ptr, size_t size );函数将ptr指向的储存空间改变为给定的大小size。 参数size可以是任意大小,大于或小于原尺寸(需要注意的是原始数据会丢失)都可以。返回值是指向新空间的指针,如果错误发生返回NULL。

    2楼失心瘋

    2021-02-09 05:14

    //运用指针运算

    int istrlen(char * str)

    {

    char *p = str;

    int len = 0;

    if(p == null)

    {

    printf("the string is null!");

    return -1;

    }

    while(*p++ != '\0')

    {

    len++;

    }

    return len;

    }

    void main()

    {

    char str[] = "fdasjfkldjs";

    int len = istrlen(str);

    printf("string %s len is%d\n", str, len);

    }

    //调用系统函数int strlen(char*);

    #include "string.h"

    void main()

    {

    char str[] = "fhdlsjklfjds";

    int len = strlen(str);

    printf("string %s len is %d\n", str, len);

    }

    我要举报

    如以上信息为低俗、色情、不良、暴力、侵权、涉及违法等信息,可以点下面链接进行举报!

    推荐资讯

    大家都在看

    展开全文
  • 关于Pytorch中怎么自定义Dataset数据集类、怎样使用DataLoader迭代加载数据,这篇官方文档已经说得很清楚了,这里就不在赘述。 现在的问题:有的时候,特别对于NLP任务来说,输入的数据可能不是定的,比如多个...
  • 首发:公众号【编程珠玑】 作者:守望先生 ... 前言 变长参数,指的是函数参数数量可变,或者说函数接受参数的数量可以不固定。...本文就来探究一下,变长参数函数的实现机制是怎样的,以及我们...
  • Pytorch 中如何处理 RNN 输入变长序列 padding 主要处理函数: torch.nn.utils.rnn.pack_padded_sequence和 torch.nn.utils.rnn.pad_packed_sequence REF2: keras搭建LSTM处理可变长度序列 LSTM的一大优势就是其...
  • C语言可变长参数函数

    千次阅读 2019-06-09 16:11:39
    1、概述 C标准中有一个默认参数提升(default argument promotions)规则。...本文结合C语言的可变长参数函数来说明默认参数提升存在的陷阱。 2、默认参数提升的定义 标准中的定义如下: Ifthe...
  • 变长数组(动态数组)

    万次阅读 2016-09-20 11:04:15
    1.变长一维数组  这里说的变长数组是指在编译时不能确定数组长度,程序在运行时需要动态分配内存空间的数组。实现变长数组最简单的是变长一维数组,你可以这样做: //文件名: array01.cpp #include using ...
  • Pytorch DataLoader 变长数据处理方法

    千次阅读 2019-03-28 16:51:34
    关于Pytorch中怎么自定义Dataset数据集类、怎样使用DataLoader迭代加载数据,这篇官方文档已经说得很清楚了,这里就不在赘述。 现在的问题:有的时候,特别对于NLP任务来说,输入的数据可能不是定的,比如多个句子...
  • 数据库中的变长类型

    千次阅读 2017-07-17 19:33:44
    1、CHAR(M), VARCHAR(M)不同之处 CHAR(M)定义的列的长度为固定的...VARCHAR(M)定义的列的长度为可变长字符串,M取值可以为0~65535之间,(VARCHAR的最大有效长度由最大行大小和使用的字符集确定。整体最大长度是65,53
  • 在C++中实现变长数组

    千次阅读 2017-03-08 17:18:19
    1.变长一维数组 这里说的变长数组是指在编译时不能确定数组长度,程序在运行时需要动态分配内存空间的数组。实现变长数组最简单的是变长一维数组,你可以这样做: //文件名: array01.cpp #include using ...
  • 字符集与编码三之定长与变长

    千次阅读 2017-04-18 14:46:14
    显然,以上的文字是以某种定长或变长的方式组合在一起的,但是关于它们如何分隔的信息则被丢弃了,于是在解释时就存在产生歧义可能了。 如何快速准确分词在中文NLP领域还是蛮有挑战的一件事,当然了,字符集...
  • C++中字符数组处理可变长字符串

    千次阅读 2015-09-04 10:16:46
    更多关于编程语言, 数据库,算法等精品内容, 请访问我的个人博客 huqijun.org #include<iostream> #include<string> using namespace std;... char * p_str = new char[arry_si...
  • C 可变长参数 VS C++11 可变长模板

    万次阅读 2014-07-03 13:50:32
    有些时候,我们定义一个函数,可能这个函数需要支持可变长参数,也就是说调用者可以
  • C,C++可变长参数实现

    千次阅读 2013-12-02 23:57:53
    转帖地址1:http://www.cnblogs.com/CUCmehp/archive/2008/12/18/1357438.html 转帖地址2:...~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 转:C/C++变长参数的实现 很多技术人员都有
  • 字符集编码 定长与变长

    千次阅读 2017-01-16 16:42:00
    显然,以上的文字是以某种定长或变长的方式组合在一起的,但是关于它们如何分隔的信息则被丢弃了,于是在解释时就存在产生歧义可能了。 如何快速准确分词在中文NLP领域还是蛮有挑战的一件事,当然了,字符集编码...
  • 问题:设置下划线时,随着文字增多,下划线延长,出现不对齐的情况 ,如下图 解决:制作表格,把不需要的边框删除,就我现在需要的效果,实现步骤如下 制作表格 设置单元格的边距为0 ...可能没这个底部居中对齐...
  • 一、为什么RNN需要处理变长输入 假设我们有情感分析的例子,对每句话进行一个感情级别的分类,主体流程大概是下图所示: 思路比较简单,但是当我们进行batch个训练数据一起计算的时候,我们会遇到多个训练样例长度...
  • tensorflow代码学习:变长序列存储

    千次阅读 2018-05-10 15:57:52
    但是如果是自己定义的变长数组,每次都要自己解析,这样很麻烦(我瞎遍的),所以tensorflow就定义了变长数组的解析方法tf.VarLenFeature,我们就不需要把边长数组变为bytes再解析了,又是一顿操作 import ...
  • python中变长参数的用法举例?

    千次阅读 2016-06-28 19:40:49
    慎用变长参数 python支持可变长度的参数列表,可以通过*arg, **kwargs这两个特殊语法来实现。以下为变长参数使用的例子: * 使用*args 来实现可变参数列表: *args用接受 一个包装为元组形式的参数列表来传递非...
  • 都知道ArrayList是基于数组的,那它是怎么实现可的呢? 创建ArrayList对象时,ArrayList有个带参数的构造函数,那个参数的意思就代表着ArrayList长度,默认情况是10。当数据多了,ArrayList容不下时,这时...
  • C++编程实现变长数组

    千次阅读 2015-11-23 19:20:10
     变长的n维数组实现起来有些麻烦,但是在工程与软件设计应用中常使用的是二维数组,所以在这里着重介绍变长的二维数组,变长的n维数组可以按照类似的方法实现。首先看一个经典的用C实现变长二维数组的例子: ...
  • 这是路径的样子,可以看到信号名是一层一层的显示,这样导致波形区域的大小会很小,看着不爽。 那么如何改变这些路径的长度呢??如下图所示,点击这里就可以切换了。
  • word怎么插入分页符

    千次阅读 2017-06-29 11:14:20
    如果回车符号是在开头,那么分页符就。Microsoft Office Word是微软公司的一个文字处理器应用程序。它最初是由Richard Brodie为了运行DOS的IBM计算机而在1983年编写的。随后的版本可运行于Apple Macintosh (1984年...
  • 第一部分,手指点击变长的木板。 这种类型的微信小游戏还是很多滴,今天KUOKUO带大家做一做。 我们新建一个工程; 加个bk背景,保存为game场景。 顺便设置一下宽和高。 好了,我们用单色节点弄个平台出来: ...
  • 对于变长表示法的解释,如下【来源自百度百科】 MTrk块类型是存放实际歌曲数据的地方。它是MIDI事件(和非MIDI事件)的序列。在MTrk块的有些数字是以叫可变长的数量的形式进行存储的。 这些数字首先每个字节用7位,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 352,171
精华内容 140,868
关键字:

怎样变长

友情链接: full_search_mpeg2.rar