将元素添加到固定长度数组并删除第一个元素的干净方法？-6ren

将元素添加到固定长度数组并删除第一个元素的干净方法？

转载作者：行者123 更新时间：2023-11-30 16:21:53

我需要一种干净的方法来向数组添加元素，如果数组“溢出”，则 0 处的元素必须替换为 1 处的元素，依此类推，直到为新元素腾出空间。

这是一个示例(伪代码):

array = [0, 0, 0, 0, 0]
// elements get added
array = [1, 0, 0, 0, 0]
...
array = [1, 2, 3, 4, 5]
// Array is full!
// Another elements gets added
array = [2, 3, 4, 5, 6]
// And so on..

我尝试在在线编译器上执行此操作，但失败得很惨，代码如下:

int main()
{
    int arr[10] = { 555, 555, 555, 555, 555, 555, 555, 555, 555, 555 };

    for (int i = 0; i < 100; i++)
    {
        int arr_idx = i % 10;

        if (arr[10] != 555)
        {
            if (arr_idx < 9)
            {
                arr[arr_idx] = arr[arr_idx + 1];
            }
            else
            {
                arr[arr_idx] = 0;
            }
        }
        else
        {
            arr[arr_idx] = i;
            printf("arr: %d", arr[arr_idx]);
        }

        printf("---\n");
        for (int j = 0; j < 10; j++)
        {
            printf("[%d]Arr = %d\n", j, arr[j]);
        }
    }
    return 0;
}

最佳答案

环形缓冲区解决方案和“随机缓冲区”解决方案都不是特别复杂。这是每一个。请注意，环形缓冲区解决方案在 16 个数组中存储 15 个值；洗牌缓冲区解决方案使用大小为 15 的数组。如果将 (1: 30) 等条目映射到 (99: 30)，这些解决方案会提供相同的输出序列> 允许数据存储方式的差异。

这两种解决方案都假设您了解结构(以及指向结构的指针)。

随机播放缓冲区

这与问题中的代码最接近。

#include <stdbool.h>
#include <stdio.h>
#include <string.h>

enum { SB_SIZE = 15 };

typedef int Data;
#define DATA_PRI_FMT "d"

struct ShuffleBuffer
{
   size_t sb_last;
   Data   sb_data[SB_SIZE];
};
typedef struct ShuffleBuffer ShuffleBuffer;

static inline void sb_shuffle(ShuffleBuffer *sbp)
{
    if (sbp->sb_last > 0)
    {
        memmove(sbp->sb_data, sbp->sb_data + 1, (SB_SIZE - 1) * sizeof(sbp->sb_data[0]));
        sbp->sb_last--;
    }
}

static void sb_insert(ShuffleBuffer *sbp, Data value)
{
    if (sbp->sb_last == SB_SIZE)
        sb_shuffle(sbp);
    sbp->sb_data[sbp->sb_last++] = value;
}

static bool sb_remove(ShuffleBuffer *sbp, Data *valuep)
{
    if (sbp->sb_last == 0)
        return false;
    *valuep = sbp->sb_data[0];
    sb_shuffle(sbp);
    return true;
}

static void sb_print(const char *tag, const ShuffleBuffer *sbp)
{
    printf("%s: (last = %zu)\n", tag, sbp->sb_last);
    int nbytes = 0;
    const char *pad = "";
    for (size_t i = 0; i < sbp->sb_last; i++)
    {
        nbytes += printf("%s(%2zu: %3" DATA_PRI_FMT ")", pad, i, sbp->sb_data[i]);
        if (nbytes > 40)
        {
            putchar('\n');
            nbytes = 0;
            pad = "";
        }
        else
            pad = " ";
    }
    if (nbytes != 0)
        putchar('\n');
}

int main(void)
{
    ShuffleBuffer rb = { 0, { 0 } };

    for (Data i = 0; i < 100; i++)
    {
        sb_insert(&rb, i * 7 + 23);
        sb_print("Post insert", &rb);
        if ((i & 1) == 1)
        {
            Data value;
            if (sb_remove(&rb, &value))
                printf("Value %" DATA_PRI_FMT " removed\n", value);
            else
                sb_print("Ring Buffer Empty", &rb);
        sb_print("Post remove", &rb);
        }
    }

    printf("Insert/remove loop over\n");

    Data value;
    while (sb_remove(&rb, &value))
        printf("Value %" DATA_PRI_FMT " removed\n", value);

    return 0;
}

环形缓冲区

#include <stdbool.h>
#include <stdio.h>

enum { RB_SIZE = 16 };

typedef int Data;
#define DATA_PRI_FMT "d"

struct RingBuffer
{
   size_t rb_head;
   size_t rb_tail;
   Data   rb_data[RB_SIZE];
};
typedef struct RingBuffer RingBuffer;

static inline size_t rb_nextpos(size_t pos)
{
    return (pos + 1) % RB_SIZE;
}

static void rb_insert(RingBuffer *rbp, Data value)
{
    rbp->rb_data[rbp->rb_head] = value;
    rbp->rb_head = rb_nextpos(rbp->rb_head);
    if (rbp->rb_tail == rbp->rb_head)
        rbp->rb_tail = rb_nextpos(rbp->rb_tail);
}

static bool rb_remove(RingBuffer *rbp, Data *valuep)
{
    if (rbp->rb_head == rbp->rb_tail)
        return false;
    *valuep = rbp->rb_data[rbp->rb_tail];
    rbp->rb_tail = rb_nextpos(rbp->rb_tail);
    return true;
}

static void rb_print(const char *tag, const RingBuffer *rbp)
{
    printf("%s: (head = %zu, tail = %zu)\n", tag, rbp->rb_head, rbp->rb_tail);
    int nbytes = 0;
    const char *pad = "";
    for (size_t i = rbp->rb_tail; i != rbp->rb_head; i = rb_nextpos(i))
    {
        nbytes += printf("%s(%2zu: %3" DATA_PRI_FMT ")", pad, i, rbp->rb_data[i]);
        if (nbytes > 40)
        {
            putchar('\n');
            nbytes = 0;
            pad = "";
        }
        else
            pad = " ";
    }
    if (nbytes != 0)
        putchar('\n');
}

int main(void)
{
    RingBuffer rb = { 0, 0, { 0 } };

    for (Data i = 0; i < 100; i++)
    {
        rb_insert(&rb, i * 7 + 23);
        rb_print("Post insert", &rb);
        if ((i & 1) == 1)
        {
            Data value;
            if (rb_remove(&rb, &value))
                printf("Value %" DATA_PRI_FMT " removed\n", value);
            else
                rb_print("Ring Buffer Empty", &rb);
        rb_print("Post remove", &rb);
        }
    }

    printf("Insert/remove loop over\n");

    Data value;
    while (rb_remove(&rb, &value))
        printf("Value %" DATA_PRI_FMT " removed\n", value);

    return 0;
}

如果您的编译器过于陈旧，无法将 inline 识别为关键字，只需在顶部附近添加 #define inline/* C99 not available */文件(或者，更好的是，获得一个能够识别近 20 年前的标准的编译器)。

环形缓冲区的输出示例

Post insert: (head = 1, tail = 0)
( 0:  23)
Post insert: (head = 2, tail = 0)
( 0:  23) ( 1:  30)
Value 23 removed
Post remove: (head = 2, tail = 1)
( 1:  30)
Post insert: (head = 3, tail = 1)
( 1:  30) ( 2:  37)
Post insert: (head = 4, tail = 1)
( 1:  30) ( 2:  37) ( 3:  44)
Value 30 removed
Post remove: (head = 4, tail = 2)
( 2:  37) ( 3:  44)
Post insert: (head = 5, tail = 2)
( 2:  37) ( 3:  44) ( 4:  51)
Post insert: (head = 6, tail = 2)
( 2:  37) ( 3:  44) ( 4:  51) ( 5:  58)
Value 37 removed
Post remove: (head = 6, tail = 3)
( 3:  44) ( 4:  51) ( 5:  58)
Post insert: (head = 7, tail = 3)
( 3:  44) ( 4:  51) ( 5:  58) ( 6:  65)
Post insert: (head = 8, tail = 3)
( 3:  44) ( 4:  51) ( 5:  58) ( 6:  65) ( 7:  72)
Value 44 removed
Post remove: (head = 8, tail = 4)
( 4:  51) ( 5:  58) ( 6:  65) ( 7:  72)
Post insert: (head = 9, tail = 4)
( 4:  51) ( 5:  58) ( 6:  65) ( 7:  72) ( 8:  79)
Post insert: (head = 10, tail = 4)
( 4:  51) ( 5:  58) ( 6:  65) ( 7:  72) ( 8:  79)
( 9:  86)
Value 51 removed
Post remove: (head = 10, tail = 5)
( 5:  58) ( 6:  65) ( 7:  72) ( 8:  79) ( 9:  86)
Post insert: (head = 11, tail = 5)
( 5:  58) ( 6:  65) ( 7:  72) ( 8:  79) ( 9:  86)
(10:  93)
Post insert: (head = 12, tail = 5)
( 5:  58) ( 6:  65) ( 7:  72) ( 8:  79) ( 9:  86)
(10:  93) (11: 100)
Value 58 removed
Post remove: (head = 12, tail = 6)
( 6:  65) ( 7:  72) ( 8:  79) ( 9:  86) (10:  93)
(11: 100)
Post insert: (head = 13, tail = 6)
( 6:  65) ( 7:  72) ( 8:  79) ( 9:  86) (10:  93)
(11: 100) (12: 107)
Post insert: (head = 14, tail = 6)
( 6:  65) ( 7:  72) ( 8:  79) ( 9:  86) (10:  93)
(11: 100) (12: 107) (13: 114)
Value 65 removed
Post remove: (head = 14, tail = 7)
( 7:  72) ( 8:  79) ( 9:  86) (10:  93) (11: 100)
(12: 107) (13: 114)
Post insert: (head = 15, tail = 7)
( 7:  72) ( 8:  79) ( 9:  86) (10:  93) (11: 100)
(12: 107) (13: 114) (14: 121)
Post insert: (head = 0, tail = 7)
( 7:  72) ( 8:  79) ( 9:  86) (10:  93) (11: 100)
(12: 107) (13: 114) (14: 121) (15: 128)
Value 72 removed
Post remove: (head = 0, tail = 8)
( 8:  79) ( 9:  86) (10:  93) (11: 100) (12: 107)
(13: 114) (14: 121) (15: 128)
Post insert: (head = 1, tail = 8)
( 8:  79) ( 9:  86) (10:  93) (11: 100) (12: 107)
(13: 114) (14: 121) (15: 128) ( 0: 135)
Post insert: (head = 2, tail = 8)
( 8:  79) ( 9:  86) (10:  93) (11: 100) (12: 107)
(13: 114) (14: 121) (15: 128) ( 0: 135) ( 1: 142)
Value 79 removed
Post remove: (head = 2, tail = 9)
( 9:  86) (10:  93) (11: 100) (12: 107) (13: 114)
(14: 121) (15: 128) ( 0: 135) ( 1: 142)
Post insert: (head = 3, tail = 9)
( 9:  86) (10:  93) (11: 100) (12: 107) (13: 114)
(14: 121) (15: 128) ( 0: 135) ( 1: 142) ( 2: 149)
Post insert: (head = 4, tail = 9)
( 9:  86) (10:  93) (11: 100) (12: 107) (13: 114)
(14: 121) (15: 128) ( 0: 135) ( 1: 142) ( 2: 149)
( 3: 156)
Value 86 removed
Post remove: (head = 4, tail = 10)
(10:  93) (11: 100) (12: 107) (13: 114) (14: 121)
(15: 128) ( 0: 135) ( 1: 142) ( 2: 149) ( 3: 156)
Post insert: (head = 5, tail = 10)
(10:  93) (11: 100) (12: 107) (13: 114) (14: 121)
(15: 128) ( 0: 135) ( 1: 142) ( 2: 149) ( 3: 156)
( 4: 163)
Post insert: (head = 6, tail = 10)
(10:  93) (11: 100) (12: 107) (13: 114) (14: 121)
(15: 128) ( 0: 135) ( 1: 142) ( 2: 149) ( 3: 156)
( 4: 163) ( 5: 170)
Value 93 removed
Post remove: (head = 6, tail = 11)
(11: 100) (12: 107) (13: 114) (14: 121) (15: 128)
( 0: 135) ( 1: 142) ( 2: 149) ( 3: 156) ( 4: 163)
( 5: 170)
Post insert: (head = 7, tail = 11)
(11: 100) (12: 107) (13: 114) (14: 121) (15: 128)
( 0: 135) ( 1: 142) ( 2: 149) ( 3: 156) ( 4: 163)
( 5: 170) ( 6: 177)
Post insert: (head = 8, tail = 11)
(11: 100) (12: 107) (13: 114) (14: 121) (15: 128)
( 0: 135) ( 1: 142) ( 2: 149) ( 3: 156) ( 4: 163)
( 5: 170) ( 6: 177) ( 7: 184)
Value 100 removed
Post remove: (head = 8, tail = 12)
(12: 107) (13: 114) (14: 121) (15: 128) ( 0: 135)
( 1: 142) ( 2: 149) ( 3: 156) ( 4: 163) ( 5: 170)
( 6: 177) ( 7: 184)
Post insert: (head = 9, tail = 12)
(12: 107) (13: 114) (14: 121) (15: 128) ( 0: 135)
( 1: 142) ( 2: 149) ( 3: 156) ( 4: 163) ( 5: 170)
( 6: 177) ( 7: 184) ( 8: 191)
Post insert: (head = 10, tail = 12)
(12: 107) (13: 114) (14: 121) (15: 128) ( 0: 135)
( 1: 142) ( 2: 149) ( 3: 156) ( 4: 163) ( 5: 170)
( 6: 177) ( 7: 184) ( 8: 191) ( 9: 198)
Value 107 removed
Post remove: (head = 10, tail = 13)
(13: 114) (14: 121) (15: 128) ( 0: 135) ( 1: 142)
( 2: 149) ( 3: 156) ( 4: 163) ( 5: 170) ( 6: 177)
( 7: 184) ( 8: 191) ( 9: 198)
Post insert: (head = 11, tail = 13)
(13: 114) (14: 121) (15: 128) ( 0: 135) ( 1: 142)
( 2: 149) ( 3: 156) ( 4: 163) ( 5: 170) ( 6: 177)
( 7: 184) ( 8: 191) ( 9: 198) (10: 205)
Post insert: (head = 12, tail = 13)
(13: 114) (14: 121) (15: 128) ( 0: 135) ( 1: 142)
( 2: 149) ( 3: 156) ( 4: 163) ( 5: 170) ( 6: 177)
( 7: 184) ( 8: 191) ( 9: 198) (10: 205) (11: 212)
Value 114 removed
Post remove: (head = 12, tail = 14)
(14: 121) (15: 128) ( 0: 135) ( 1: 142) ( 2: 149)
( 3: 156) ( 4: 163) ( 5: 170) ( 6: 177) ( 7: 184)
( 8: 191) ( 9: 198) (10: 205) (11: 212)
Post insert: (head = 13, tail = 14)
(14: 121) (15: 128) ( 0: 135) ( 1: 142) ( 2: 149)
( 3: 156) ( 4: 163) ( 5: 170) ( 6: 177) ( 7: 184)
( 8: 191) ( 9: 198) (10: 205) (11: 212) (12: 219)
Post insert: (head = 14, tail = 15)
(15: 128) ( 0: 135) ( 1: 142) ( 2: 149) ( 3: 156)
( 4: 163) ( 5: 170) ( 6: 177) ( 7: 184) ( 8: 191)
( 9: 198) (10: 205) (11: 212) (12: 219) (13: 226)
Value 128 removed
Post remove: (head = 14, tail = 0)
( 0: 135) ( 1: 142) ( 2: 149) ( 3: 156) ( 4: 163)
( 5: 170) ( 6: 177) ( 7: 184) ( 8: 191) ( 9: 198)
(10: 205) (11: 212) (12: 219) (13: 226)
Post insert: (head = 15, tail = 0)
( 0: 135) ( 1: 142) ( 2: 149) ( 3: 156) ( 4: 163)
( 5: 170) ( 6: 177) ( 7: 184) ( 8: 191) ( 9: 198)
(10: 205) (11: 212) (12: 219) (13: 226) (14: 233)
Post insert: (head = 0, tail = 1)
( 1: 142) ( 2: 149) ( 3: 156) ( 4: 163) ( 5: 170)
( 6: 177) ( 7: 184) ( 8: 191) ( 9: 198) (10: 205)
(11: 212) (12: 219) (13: 226) (14: 233) (15: 240)
Value 142 removed
Post remove: (head = 0, tail = 2)
( 2: 149) ( 3: 156) ( 4: 163) ( 5: 170) ( 6: 177)
( 7: 184) ( 8: 191) ( 9: 198) (10: 205) (11: 212)
(12: 219) (13: 226) (14: 233) (15: 240)
Post insert: (head = 1, tail = 2)
( 2: 149) ( 3: 156) ( 4: 163) ( 5: 170) ( 6: 177)
( 7: 184) ( 8: 191) ( 9: 198) (10: 205) (11: 212)
(12: 219) (13: 226) (14: 233) (15: 240) ( 0: 247)
…
Post insert: (head = 3, tail = 4)
( 4: 611) ( 5: 618) ( 6: 625) ( 7: 632) ( 8: 639)
( 9: 646) (10: 653) (11: 660) (12: 667) (13: 674)
(14: 681) (15: 688) ( 0: 695) ( 1: 702) ( 2: 709)
Post insert: (head = 4, tail = 5)
( 5: 618) ( 6: 625) ( 7: 632) ( 8: 639) ( 9: 646)
(10: 653) (11: 660) (12: 667) (13: 674) (14: 681)
(15: 688) ( 0: 695) ( 1: 702) ( 2: 709) ( 3: 716)
Value 618 removed
Post remove: (head = 4, tail = 6)
( 6: 625) ( 7: 632) ( 8: 639) ( 9: 646) (10: 653)
(11: 660) (12: 667) (13: 674) (14: 681) (15: 688)
( 0: 695) ( 1: 702) ( 2: 709) ( 3: 716)
Insert/remove loop over
Value 625 removed
Value 632 removed
Value 639 removed
Value 646 removed
Value 653 removed
Value 660 removed
Value 667 removed
Value 674 removed
Value 681 removed
Value 688 removed
Value 695 removed
Value 702 removed
Value 709 removed
Value 716 removed

时间

由于主循环重复 100 次，如果禁用打印，两个程序之间并没有真正可测量的差异，而如果启用打印，则只能勉强测量且不完全可靠。

在禁用打印且缓冲区大小为 15 或 16 的情况下，主程序中循环 100 万次对于环形缓冲区需要 4.5 毫秒，而对于随机缓冲区则需要 9.0 毫秒。将缓冲区大小更改为 2047 或 2048，环形缓冲区的时间为 3.7 毫秒，而随机缓冲区的时间为 87.3 毫秒。启用打印后，环形缓冲区在打印中完成的轻微额外工作淹没了不洗牌带来的性能增益；这两个程序的运行时间基本相同:4,546.5 毫秒 vs 4,477.2 毫秒(因此，在启用打印的情况下，洗牌缓冲区的速度稍快一些 — 很大程度上是因为它仅生成 353 MiB 的数据，而环形缓冲区生成 368 MiB 的数据 —随着计时运行，数据被写入 /dev/null)。

测量的时间是可执行文件的运行时间，而不是 CPU 时间本身。测试使用配备 2.9 GHz Intel Core i7、16 GiB 2133 MHz LPDDR3 RAM 的 15 英寸 MacBook Pro(2017 年)，运行 macOS 10.14.3 Mojave 并使用自制的 GCC 8.2.0。速度测试为困难 - 我认为没有打印的结果是有意义的，但是 YMMV 。如果您需要演示“打印很慢”，这很可能是一个不错的选择。

关于将元素添加到固定长度数组并删除第一个元素的干净方法？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54680129/

文章推荐： c - 在 C 中解析字符串，不使用 Strtok()

文章推荐：在结构上创建双指针以按索引使用(类似于数组，但最大大小未知)

文章推荐： c++ - 海湾合作委员会ld : symbol(s) not found for architecture i386

文章推荐： c - C语言中的大整数？

html - 具有全屏高度的 3 列布局(固定-流体-固定)
我正在尝试实现 3 列固定-流体-固定布局。此外，布局的高度必须占据整个屏幕，使其看起来像从上到下的 3 个实心列。总结: Left-column: fixed-width Center-col
html - 具有最小宽度的 3 列布局(固定、流动、固定)
我在网上搜索过，似乎找不到一个干净、简单、所有浏览器都友好的 3 列布局。我希望有 3 列布局，左列固定为 200px，右列固定为 200px，中间列为剩余宽度，但最小宽度为 600px。所以整体最
css - 如何创建 3 列布局(固定、固定、流动)
关闭。这个问题需要更多focused .它目前不接受答案。想改进这个问题吗？更新问题，使其只关注一个问题 editing this post . 关闭 8 年前。 Improve this q
audio - 音频归一化/固定？
我正在使用一些音频指纹技术来标记长录音中的歌曲。例如，在广播节目中的记录。指纹机制工作正常，但我在归一化(或下采样)方面遇到问题。在这里您可以看到两首相同的歌曲，但波形不同。我知道我应该进行一些直流
c++ - 固定，设定精度功能
为什么使用cout调用setprecision和fixed以及其他iomanip函数不像例如name.find('')plz这样的字符串函数最佳答案它们允许您以以下方式链接操作: cout <<
jquery - 固定/跟随侧边栏的问题
我正在尝试创建一个侧边栏，当用户向下滚动页面时，该侧边栏会跟随用户，并且我设法使用以下代码实现了效果: 标记 Javas
macos - 内存是否被锁定(固定)？
我正在尝试设置一些性能分析以及影响缓冲策略的运行时决策。我的应用程序收到一个指向由库(CUDA 或 OpenCL)分配的缓冲区的指针。如何测试内存区域是否被页面锁定？据我所知，POSIX 给了我们
C# - 固定/内联数组
我正在用 C# 编写一个 B+ 树实现，我为我的应用程序选择的树实现有一个非常特定的结构，它是缓存敏感的。为了实现这些属性，它对树节点有严格的布局策略。我想要的只是使用 C# 的 fixed 来表达
Android，在屏幕底部定位一个元素，固定
我试图通过将 fragment 注入(inject)容器来在每个屏幕的底部放置一个广告 View 。通过使用 LinearLayout，我可以将 adview 置于操作栏下方的顶部。我已经尝试了 Re
jquery - 导航 - 固定
我正在尝试创建一个导航稍微复杂的网站。我已经让导航看起来像我想要的初始加载，但现在我试图让它粘性导航到滚动顶部。我已经能够在导航栏到达顶部时创建一个类，但无法使其粘滞。每次我添加一个位置时，它都会跳回
css - 固定、动态高度元素占用空间的解决方案
首先，我正在寻找一个纯 CSS 解决方案。我可以使用 JavaScript 非常轻松地做到这一点，所以不要费心给我提示如何在 JS 中做到这一点。我有一个包含 3 个容器的网页。其中 2 个是固定的
CSS 固定/绝对定位到较早的亲戚？
我猜这里有一种 super 特例。我正在处理许多包含。现在我正在一个包含的内容文件中编码。我需要一个灯箱，它有一个 20% 的黑色背景覆盖整个页面，包括本身固定的标题，并在先前的 PHP 文件中设置
css - 固定/相对定位 :
我正在尝试制作一个包含两个“固定”侧边栏图像和一个“固定”标题图像的页面。由于标题是固定的(距顶部 0 到 10%)。我不希望页眉图像与页面上的任何文本重叠。我尝试将段落标记定位为“相对”，并将其设置
CSS:居中位置:固定
我遇到了一个(水平)居中固定位置元素的解决方案，如下所示: element { width: 200px; position: fixed; left: 0; righ
HTML 正文高度 - 固定？
我试图让我的网站主体具有固定的高度(我想!)。无论如何，站点正文只是白色，边框大小为 1。基本上，正文的大小取决于其中的内容，例如，随着添加更多内容，它会自动调整大小。我想要的是垂直滚动条，这样主
css 布局(固定)
是否可以在 css 中创建 master-detail-states 布局？我需要 3 个占位符: +---------------+-------+ | A | B
同一请求中的 SSL 固定
我的问题是，我是否必须在每个 Get/Post 请求之前单独请求检查 SSL Pinning OkHttpClient client = new OkHttpClient.Builder().cert
algorithm - (固定)平衡树的摊销成本
假设我有一个具有 N 个节点的常量(一旦构建就不会改变)平衡树，每个内部节点都有 p 个子节点。显然，访问节点的最坏情况是 logp(N)。但是访问 r 个节点的摊销成本呢？如果我们按升序访问它们(有
php - 如何防止php项目中的 session 固定？
我知道会话固定是用php破解网站的方法。会话固定是一种允许攻击者劫持有效用户会话的攻击 session fixation 但我不知道这可以防止我的项目中出现此问题。是描述解决方案的方式或样本。最
jQuery Masonry 固定/前置元素
我在 jquery 砖石布局内有一个导航元素，我想将其修复到特定位置，比如右上角。是否可以这样做，以便所有其他元素都位于它周围？诸如前置导航之类的东西.. 这是我的代码:http://jsfiddl

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城