Dinamicko produzavanje duzine niza

Code:

#include <iostream>
using namespace std;

int main(int argc, char *argv[])
{
    int x[5];
    int a[5];
    
    for(int i=0;i<5;i++){
        x[i] = 13; // ceo niz a ispunimo trinaesticama
    }
    
    a[8] = 17;
    
    for(int i=0;i<5;i++){
        cout << x[i] << endl; // ovde bi trebalo da ispise sve trinaestice, ali...
    }
}

Code:

#include <iostream>
#include <vector>
using namespace std;

int main(int argc, char *argv[])
{
    vector<int> mojniz;
    mojniz.push_back(13);
    mojniz.push_back(17);

    cout << mojniz[0] << endl << mojniz[1];
}

Code:

   void newSize(int **n,int size,int oldSize = 0){
       int *tmp;
       tmp = new int[size];  
       if (oldSize > 0) memcpy(tmp,*n,4*oldSize);
       delete *n;
       *n = tmp;
   }
}

Code:

#include <cstdlib>
#include <iostream>
using namespace std;

void newSize(int **n,int size,int oldSize = 0){
   int *tmp;
   tmp = new int[size];  
   if (oldSize > 0) memcpy(tmp,*n,4*oldSize);
   delete *n;
   *n = tmp;
}

int main(int argc, char *argv[])
{   
    int i;
    int *d;
    newSize(&d,10);
    for (i = 0;i<10;i++)
      d[i] = i;  
    newSize(&d,20,10);
    for (i = 0;i<10;i++)
      d[i + 10] = i;  
    for (i = 0; i < 20; ++i)
      cout<<d[i]<<endl;
    system("pause");  
    return EXIT_SUCCESS;
}

Code:

static void *realloc(void *ptr, size_t size)
{
    void *p;
    u_long osize, index;
    struct pginfo **mp;
    int i;

    if (suicide)
    abort();

    if (!malloc_started) {
    wrtwarning("malloc() has never been called\n");
    return (NULL);
    }

    index = ptr2index(ptr);

    if (index < malloc_pageshift) {
    wrtwarning("junk pointer, too low to make sense\n");
    return (NULL);
    }

    if (index > last_index) {
    wrtwarning("junk pointer, too high to make sense\n");
    return (NULL);
    }

    mp = &page_dir[index];

    if (*mp == MALLOC_FIRST) {            /* Page allocation */

    /* Check the pointer */
    if ((u_long)ptr & malloc_pagemask) {
        wrtwarning("modified (page-) pointer\n");
        return (NULL);
    }

    /* Find the size in bytes */
    for (osize = malloc_pagesize; *(++mp) == MALLOC_FOLLOW;)
        osize += malloc_pagesize;

        if (!malloc_realloc &&            /* Unless we have to, */
      size <= osize &&            /* .. or are too small, */
      size > (osize - malloc_pagesize)) {    /* .. or can free a page, */
        if (malloc_junk)
        memset((char *)ptr + size, SOME_JUNK, osize-size);
        return (ptr);            /* ..don't do anything else. */
    }

    } else if (*mp >= MALLOC_MAGIC) {        /* Chunk allocation */

    /* Check the pointer for sane values */
    if ((u_long)ptr & ((1UL<<((*mp)->shift))-1)) {
        wrtwarning("modified (chunk-) pointer\n");
        return (NULL);
    }

    /* Find the chunk index in the page */
    i = ((u_long)ptr & malloc_pagemask) >> (*mp)->shift;

    /* Verify that it isn't a free chunk already */
        if ((*mp)->bits[i/MALLOC_BITS] & (1UL<<(i%MALLOC_BITS))) {
        wrtwarning("chunk is already free\n");
        return (NULL);
    }

    osize = (*mp)->size;

    if (!malloc_realloc &&        /* Unless we have to, */
      size <= osize &&        /* ..or are too small, */
      (size > osize/2 ||        /* ..or could use a smaller size, */
      osize == malloc_minsize)) {    /* ..(if there is one) */
        if (malloc_junk)
        memset((char *)ptr + size, SOME_JUNK, osize-size);
        return (ptr);        /* ..don't do anything else. */
    }

    } else {
    wrtwarning("pointer to wrong page\n");
    return (NULL);
    }

    p = imalloc(size);

    if (p != NULL) {
    /* copy the lesser of the two sizes, and free the old one */
    /* Don't move from/to 0 sized region !!! */
    if (osize != 0 && size != 0) {
        if (osize < size)
        memcpy(p, ptr, osize);
        else
        memcpy(p, ptr, size);
    }
    ifree(ptr);
    }
    return (p);
}

Code:

a=(int*)malloc(10*sizeof(int));

Code:

n-ti_clan=*(a+n-1);
//n<10