Aller au contenu
San Andreas Multiplayer

c_vector 0x210

   (0 avis)

À propos de ce fichier

Après avoir vu une include qui implémente les vectors avec le plugin pawn-memory, j'me suis dit que j'allais coder une include similaire mais sans le plugin pawn-memory.

Pour ça j'ai quand même utilisé y_malloc, mais je ferai surement une version sans si j'ai le courage.

 

J'ai implémenté cette include de deux façons, car au moment où j'écrie cette description, il y a un bug avec y_malloc du coup je l'avais résolu de mon coté mais j'ai tout de même créé une version qui contourne ce bug, mais qui est un peu moins safe si certaines parties de y_malloc changent (chose qui ne devrait pas arriver).

J'vous glisse le Pastebin de la version 0x100 (qui fonctionne mal à cause d'un bug de y_malloc) : https://pastebin.com/8cHyEfe3

 

Les fonctions :

vector_push_back_value(&Vector:vector, value);
vector_push_back_array(&Vector:vector, const array[], size = sizeof(array));
vector_remove(&Vector:vector, index);
vector_get_value(Vector:vector, index);
vector_get_array(Vector:vector, index, array[], size = sizeof(array));
vector_set_value(Vector:vector, index, value);
vector_set_array(Vector:vector, index, array[], size = sizeof(array));
bool:vector_is_storing_array(Vector:vector);
vector_free(&Vector:vector);
vector_get_array_size(Vector:vector, index);
vector_get_size(Vector:vector);

 

J'ai implémenté aussi 2 fonctions "d'iterators" qui fonctionnent avec y_iterate (foreach) :

iterfunc stock vector(&iterstate, cur, Vector:vector, array[] = cellmin, size = sizeof(array));
iterfunc stock array(&iterstate, cur, const array[], size, size2 = sizeof(array));

 

Un exemple d'utilisation :

Révélation

#include <a_samp>
#include <c_vector>
 
main() {
    new
        Vector:v = VECTOR_NULL,
        a[8] = {444, ...},
        b[4] = {555, ...},
        c[16] = {666, ...},
        d[2] = {777, ...},
        e[8] = {888, ...},
        f[4] = {999, ...},
        g[8] = {222, ...},
        tmp[16];
 
    vector_push_back_value(v, 444);
    vector_push_back_value(v, 555);
    vector_push_back_value(v, 666);
    vector_push_back_value(v, 777);
    vector_push_back_value(v, 888);
 
    print("-------------------");
    print("push 444, 555, 666, 777 and 888");
 
    foreach(new value : vector(v)) {
        printf("%d", value);
    }
 
    print("-------------------");
    printf("vector_is_storing_array : %d", vector_is_storing_array(v));
 
    vector_remove(v, 1);
 
    print("-------------------");
    print("remove index(1)=555");
 
    foreach(new value : vector(v)) {
        printf("%d", value);
    }
 
    vector_push_back_value(v, 555);
    vector_push_back_value(v, 999);
 
    print("-------------------");
    print("push 555 and 999");
 
    foreach(new value : vector(v)) {
        printf("%d", value);
    }
 
    vector_set_value(v, 3, 1888);
 
    print("-------------------");
    print("set index(3)=888 -> index(3)=1888");
 
    foreach(new value : vector(v)) {
        printf("%d", value);
    }
 
    vector_remove(v, 5);
    vector_remove(v, 4);
    vector_remove(v, 2);
    vector_remove(v, 1);
    vector_remove(v, 0);
 
    print("-------------------");
    print("remove index(5)=999, index(4)=555, index(2)=777, index(1)=666 and index(0)=444");
 
    foreach(new value : vector(v)) {
        printf("%d", value);
    }
 
    vector_remove(v, 0);
 
    print("-------------------");
    print("remove index(0)=1888 | vector is free");
 
    foreach(new value : vector(v)) {
        printf("%d", value);
    }
 
    print("-------------------");
 
    if(v == VECTOR_NULL) {
        print("the vector is null");
    }
 
    vector_push_back_array(v, a);
    vector_push_back_array(v, b);
    vector_push_back_array(v, c);
    vector_push_back_array(v, d);
    vector_push_back_array(v, e);
 
    print("-------------------");
    print("push array(444), array(555), array(666), array(777) and array(888)");
 
    foreach(new size : vector(v, tmp)) {
        printf("size(%d)", size);
        foreach(new value : array(tmp, size)) {
            printf("%d", value);
        }
    }
 
    print("-------------------");
    printf("vector_is_storing_array : %d", vector_is_storing_array(v));
 
    vector_remove(v, 1);
 
    print("-------------------");
    print("remove index(1)=array(555)");
 
    foreach(new size : vector(v, tmp)) {
        printf("size(%d)", size);
        foreach(new value : array(tmp, size)) {
            printf("%d", value);
        }
    }
 
    vector_push_back_array(v, f);
    vector_push_back_array(v, b);
 
    print("-------------------");
    print("push array(999) and array(555)");
 
    foreach(new size : vector(v, tmp)) {
        printf("size(%d)", size);
        foreach(new value : array(tmp, size)) {
            printf("%d", value);
        }
    }
 
    vector_set_array(v, 2, g);
   
    print("-------------------");
    print("set index(2)=array(777) -> index(2)=array(222)");
 
    foreach(new size : vector(v, tmp)) {
        printf("size(%d)", size);
        foreach(new value : array(tmp, size)) {
            printf("%d", value);
        }
    }
 
    vector_remove(v, 5);
    vector_remove(v, 4);
    vector_remove(v, 2);
    vector_remove(v, 1);
    vector_remove(v, 0);
 
    print("-------------------");
    print("remove index(5)=array(555), index(4)=array(999), index(2)=array(222), index(1)=array(666) and index(0)=array(444)");
 
    foreach(new size : vector(v, tmp)) {
        printf("size(%d)", size);
        foreach(new value : array(tmp, size)) {
            printf("%d", value);
        }
    }
 
    vector_remove(v, 0);
 
    print("-------------------");
    print("remove index(0)=array(888) | vector is free");
 
    foreach(new size : vector(v, tmp)) {
        printf("size(%d)", size);
        foreach(new value : array(tmp, size)) {
            printf("%d", value);
        }
    }
 
    print("-------------------");
 
    if(v == VECTOR_NULL) {
        print("the vector is null");
    }
}

 

 

Résultat :

Révélation

-------------------
push 444, 555, 666, 777 and 888
444
555
666
777
888
-------------------
vector_is_storing_array : 0
-------------------
remove index(1)=555
444
666
777
888
-------------------
push 555 and 999
444
666
777
888
555
999
-------------------
set index(3)=888 -> index(3)=1888
444
666
777
1888
555
999
-------------------
remove index(5)=999, index(4)=555, index(2)=777, index(1)=666 and index(0)=444
1888
-------------------
remove index(0)=1888 | vector is free
-------------------
the vector is null
-------------------
push array(444), array(555), array(666), array(777) and array(888)
size(8)
444
444
444
444
444
444
444
444
size(4)
555
555
555
555
size(16)
666
666
666
666
666
666
666
666
666
666
666
666
666
666
666
666
size(2)
777
777
size(8)
888
888
888
888
888
888
888
888
-------------------
vector_is_storing_array : 1
-------------------
remove index(1)=array(555)
size(8)
444
444
444
444
444
444
444
444
size(16)
666
666
666
666
666
666
666
666
666
666
666
666
666
666
666
666
size(2)
777
777
size(8)
888
888
888
888
888
888
888
888
-------------------
push array(999) and array(555)
size(8)
444
444
444
444
444
444
444
444
size(16)
666
666
666
666
666
666
666
666
666
666
666
666
666
666
666
666
size(2)
777
777
size(8)
888
888
888
888
888
888
888
888
size(4)
999
999
999
999
size(4)
555
555
555
555
-------------------
set index(2)=array(777) -> index(2)=array(222)
size(8)
444
444
444
444
444
444
444
444
size(16)
666
666
666
666
666
666
666
666
666
666
666
666
666
666
666
666
size(8)
222
222
222
222
222
222
222
222
size(8)
888
888
888
888
888
888
888
888
size(4)
999
999
999
999
size(4)
555
555
555
555
-------------------
remove index(5)=array(555), index(4)=array(999), index(2)=array(222), index(1)=array(666) and index(0)=array(444)
size(8)
888
888
888
888
888
888
888
888
-------------------
remove index(0)=array(888) | vector is free
-------------------
the vector is null

 

 

Benchmark seulement sur les boucles :

Révélation

c_vector.inc 0x100 (y_malloc include (YSI 5.x))
values:
iter:100000 | values:5 | 356ms
iter:100000 | values:10 | 597ms
iter:100000 | values:15 | 748ms
arrays:
iter:100000 | arrays:5 | 1177ms
iter:100000 | arrays:10 | 2316ms
iter:100000 | arrays:15 | 3311ms

c_vector.inc 0x200 (y_malloc include (YSI 5.x)
values:
iter:100000 | values:5 | 168ms
iter:100000 | values:10 | 344ms
iter:100000 | values:15 | 592ms
arrays:
iter:100000 | arrays:5 | 819ms
iter:100000 | arrays:10 | 1653ms
iter:100000 | arrays:15 | 2676ms

vector.inc (pawn-memory plugin)
values:
iter:100000 | values:5 | 311ms
iter:100000 | values:10 | 600ms
iter:100000 | values:15 | 848ms
arrays:
iter:100000 | arrays:5 | 619ms
iter:100000 | arrays:10 | 1275ms
iter:100000 | arrays:15 | 1678ms

 

 


Quoi de neuf dans la version 0x210 ?   Voir le journal des modifications

Publiée

J'ai fait quelque chose de plus safe pour accéder aux pointeurs et valeurs qu'allouent malloc, en passant par des macros implémentées directement dedans.

J'ai aussi modifié légèrement les fonctions d'itérateurs vector() et array() et j'ai aussi rajouté vector_reverse() et array_reverse().

J'ai ajouté une fonction vector_sort() que vous pouvez utiliser comme ceci :

Révélation

new 
        Vector:v = VECTOR_NULL;

    for(new i = 0; i < 30; i++) {
        vector_push_back_value(v, random(5) ? random(20) : random(2000));
    }

    foreach(new value : vector(v)) {
        printf("%d", value);
    }

    print("----------------------");
    print("vector_sort::desc");

    vector_sort(v, E_VECTOR_SORT_DESC);

    foreach(new value : vector(v)) {
        printf("%d", value);
    }

    print("----------------------");
    print("vector_sort::asc");

    vector_sort(v);

    foreach(new value : vector(v)) {
        printf("%d", value);
    }

    vector_free(v);

 

 

Pour les fonctions d'itérateurs, voici un exemple :

Révélation

new 
        Vector:v = VECTOR_NULL,
        a[16] = {1, 2, ...},
        b[16],
        c[8],
        d[32];

    print("----------------------");
    print("Simple array:");
    foreach(new value : array(a)) {
        printf("%d", value);
    }
    print("----------------------");
    print("Simple array reverse:");
    foreach(new value : array_reverse(a)) {
        printf("%d", value);
    }

    vector_push_back_array(v, a);

    print("----------------------");
    print("Vector array to array(16):");
    foreach(new size : vector(v, b)) {
        foreach(new value : array(b)) {
            printf("%d", value);
        }
    }

    print("----------------------");
    print("Vector array to array(8):");
    foreach(new size : vector(v, c)) {
        foreach(new value : array(c)) {
            printf("%d", value);
        }
    }

    print("----------------------");
    print("Vector array to array(32):");
    foreach(new size : vector(v, d)) {
        foreach(new value : array(d, size)) {
            printf("%d", value);
        }
    }

    print("----------------------");
    print("Vector array to array(16) reverse:");
    foreach(new size : vector(v, b)) {
        foreach(new value : array_reverse(b)) {
            printf("%d", value);
        }
    }

    print("----------------------");
    print("Vector array to array(8) reverse:");
    foreach(new size : vector(v, c)) {
        foreach(new value : array_reverse(c)) {
            printf("%d", value);
        }
    }

    print("----------------------");
    print("Vector array to array(32) reverse:");
    foreach(new size : vector(v, d)) {
        foreach(new value : array_reverse(d, size)) {
            printf("%d", value);
        }
    }

 

 




Retour utilisateur

Vous pouvez donner un avis uniquement après avoir téléchargé le fichier.

Il n’y a aucun avis à afficher.

×