С ++ vettore equivalente in C

Question

Ho un codice (С ++) che assomiglia a questo

vector<int> values[10000]; 

int i, j; 
while (.....) { 
    scanf("%d%d", &i, &j); 
    values[i].push_back(j); 
    values[j].push_back(i); 
} 

ma voglio riscrivere il codice a C. Come posso fare questo?

Ho studiato l'opportunità di creare il proprio stack, ma forse ho un modo più leggero per riscrivere questo codice, forse array bidimensionali. Finora non riesco a pensare a come questo remake, spero che qualcuno più esperto mi dica come farlo :)

Scusate ragazzi, ha aggiunto un esempio più avanzato ...

Answer 1

Non v'è alcun standard C equivalente a il vettore C++, sebbene tu possa creare una struct basata sul vettore in C++. Struct sarebbe

• stessa ridimensionare se i limiti di matrice si passano la dimensione massima
• eseguire le operazioni simili a quella di un vettore

O

• creare uno stack lista collegata struct che simula quello di un vettore C++

Answer 2

Un equivalente approssimativo di un C++ vector sarebbe un array C di ridimensionamento (per tenere conto di più elementi di quelli disponibili).

Ergo, l'equivalente di una matrice di vettori sarebbe un array di puntatori (una matrice di matrici non la taglierebbe a causa del vincolo di ridimensionamento).

int* values[1000]; 

Avrai bisogno di spiegare le dimensioni, però, così si potrebbe neanche farlo esternamente o avvolgere la logica all'interno di una struttura.

int sizes[1000]; 
int noElements[1000] 
//all sizes and noElements initially 0 

for (int i = 0; i < 10; i++) { 
    if (noElements[i] >= sizes[i]) 
    { 
     //allocate more memory for values[i]; 
     //copy old contents into the new memory 
     //update sizes[i] 
    } 
    values[i][noElements] = 10; 
    noElements++; 
} 

Answer 3

Invece di eseguire il rollover, è possibile provare una libreria contenitore C, ad es. http://code.google.com/p/ccl/

Answer 4

Qualcosa di simile a questo:

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


typedef struct _darray 
{ 
    size_t size; 
    size_t actual_size; 
    int *content; 
} darray; 


void darray_create(darray *d) 
{ 

    d->actual_size = d->size = 0; 
    d->content = NULL; 
} 

void darray_append(darray *d, int v) 
{ 
    if (d->size+1 > d->actual_size) 
    { 
    size_t new_size; 
    if (!d->actual_size) 
    { 
     new_size = 1; 
    } 
    else 
    { 
     new_size = d->actual_size * 2; 
    } 
    int *temp = realloc(d->content, sizeof(int) * new_size); 
    if (!temp) 
    { 
     fprintf(stderr, "Failed to extend array (new_size=%zu)\n", new_size); 
     exit(EXIT_FAILURE); 
    } 
    d->actual_size = new_size; 
    d->content = temp; 
    } 
    d->content[d->size] = v; 
    d->size++; 
} 

const int* darray_data(darray *d) 
{ 
    return d->content; 
} 


void darray_destroy(darray *d) 
{ 
    free(d->content); 
    d->content = NULL; 
    d->size = d->actual_size = 0; 
} 


size_t darray_size(darray *d) 
{ 
    return d->size; 
} 


int main() 
{ 
    int i; 
    darray myarray; 
    const int *a; 

    darray_create(&myarray); 

    for(i = 0; i < 100; i++) 
    { 
    darray_append(&myarray, i); 
    } 
    a = darray_data(&myarray); 
    for(i = 0; i < darray_size(&myarray); i++) 
    { 
    printf("i=%d, value=%d\n", i, a[i]); 
    } 
    darray_destroy(&myarray); 
} 

Answer 5

Sono affraid dovrete lavorare con la memoria heap nella moda anni 80 nella piana C.

typedef struct tagArrayDesc { 
    int* arr; 
    size_t top; 
    size_t reserved; 
} ArrayDesc; 

#define EC(NAME, T) size_t ensure_capacity##NAME##(size_t size,   \ 
                T** vec,    \ 
                size_t reserved)  \ 
{                   \ 
    size_t new_reserved;              \ 
    new_reserved = reserved;             \ 
    if (reserved < size) {             \ 
    if (reserved != 0) {             \ 
     new_reserved *= 2;             \ 
    } else {                \ 
     new_reserved = 0x10;             \ 
    }                  \ 
    }                  \ 
    if (new_reserved < size) {            \ 
    new_reserved = (size * 4)/3;           \ 
    }                  \ 
    if (new_reserved > reserved) {           \ 
    *vec = realloc(*vec, sizeof(**vec) * new_reserved);     \ 
    memset((*vec) + reserved, 0, sizeof(T) * (new_reserved - reserved)); \ 
    }                  \ 
    return new_reserved;              \ 
} 

EC(_int, int) 
EC(_array_desc, ArrayDesc) 

int main() 
{ 
    ArrayDesc* rows = NULL; 
    size_t rows_size = 0; 
    size_t rows_reserved = 0; 
    while (true) { 
    int i, j; 
    scanf("%d%d", &i, &j); 
    rows_reserved = ensure_capacity_array_desc(i + 1, &rows, rows_reserved); 
    rows[i].reserved = ensure_capacity_int(j + 1, &rows[i].arr, rows[i].reserved); 
    rows[i].arr[j] = 42; 
    } 
    return 0; 
} 

Answer 6

si deve lavorare con dynamic memory allocation . Non è difficile. Ogni volta che deve essere inserito un nuovo oggetto basta usare realloc. Somethink che assomiglia a questo:

#include <cstdlib> 

typedef struct { } UserType; 

int currentSize = 0; 
UserType* values; 

/// Add new value to values method 
void addValue(const UserType& newValue) 
{ 
    ++currentSize; 
    values = static_cast<UserType*>(realloc(values, currentSize)); 
    if (values == NULL) 
     // memory allocation filed, place fix code here 
     *(values + currentSize) = newValue; 
} 

Ricordate, u have a utilizzare free per la memoria libera del values. Inoltre, potresti non liberare memoria allocata se finirà il lavoro al momento.

Answer 7

Si può provare qualcosa di simile:

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


struct vector 
{ 
    int len; 
    int allocated; 
    int step; 
    int *data; 
}; 


#define INIT_SIZE 1 


void init_vector(struct vector *v) 
{ 
    v->len = 0; 
    v->allocated = 0; 
    v->step = 2; 
    v->data = NULL; 
} 


int append(struct vector *v, int item) 
{ 
    if (!v->data) 
    { 
     v->data = malloc(INIT_SIZE * sizeof(int)); 

     if (!v->data) 
      return -1; 

     v->allocated = INIT_SIZE; 
    } 
    else 
     if (v->len >= v-vallocated) 
     { 
      int *tmp = realloc(v->data, 
         v->allocated * v->step * sizeof(int)); 

      if (!tmp) 
       return -1; 

      v->data = tmp; 
      v->allocated *= v->step; 
     } 

    v->data[v->len] = item; 
    v->len++; 

    return 0; 
} 


int delete(struct vector *v, int index) 
{ 
    if (index < 0 || index >= v->len) 
     return -1; 

    memmove(v->data + index, v->data + index + 1, 
         (v->len - index - 1) * sizeof(int)); 
    v->len--; 

    return 0; 
} 


void print(const struct vector *v) 
{ 
    printf("Array:\n"); 

    for (int i = 0; i < v->len; i++) 
     printf("%d ", v->data[i]); 

    printf("\n"); 
} 


int main(void) 
{ 
    struct vector v; 
    int rc; 

    init_vector(&v); 

    rc = append(&v, 1); 
    assert(rc == 0); 

    rc = append(&v, 2); 
    assert(rc == 0); 

    rc = append(&v, 3); 
    assert(rc == 0); 

    rc = append(&v, 4); 
    assert(rc == 0); 

    rc = append(&v, 5); 
    assert(rc == 0); 

    print(&v); 

    rc = delete(&v, 2); 
    assert(rc == 0); 

    print(&v); 

    free(v.data); 

    return 0; 
}