自学教程：C++ srealloc函数代码示例

static char *readline(char **line, size_t *linesize, size_t *length, FILE *fp){	int c;	size_t n = 0;	if (*line == NULL || *linesize < LSIZE + n + 1)		*line = srealloc(*line, *linesize = LSIZE + n + 1);	for (;;) {		if (n >= *linesize - LSIZE / 2)			*line = srealloc(*line, *linesize += LSIZE);		c = getc(fp);		if (c != EOF) {			(*line)[n++] = c;			(*line)[n] = '/0';			if (c == '/n')				break;		} else {			if (n > 0)				break;			else				return NULL;		}	}	*length = n;	return *line;}

void *xrealloc(void *ptr,int size,int ID){	struct mem_block *mem;	if (ptr==NULL) return xcalloc(size,ID);	mem=(void*)((char*)(ptr)-sizeof(struct mem_block));	rem_block(mem);#ifdef DEBUG	mem=srealloc(mem,size+sizeof(struct mem_block)+32,ID);#else	mem=srealloc(mem,size+sizeof(struct mem_block),ID);#endif	if (!mem) return NULL;	mem->size=size;	mem->ID=ID;#ifdef DEBUG	memcpy(mem->magic,       "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345",32);	memcpy(mem->content+size,"abcdefghijklmnopqrstuvwxyz678901",32);#endif	add_block(mem);	return mem->content;}

static voidaddcmd(const char *s){	if (a_cnt >= a_maxarg - 4096) {		a_maxarg += 8192;		a_vec = srealloc(a_vec, a_maxarg * sizeof *a_vec);	}	if (iflag && contains(s, iflag)) {		if (replcnt >= replsiz) {#ifdef	WEIRD_LIMITS			if (replcnt >= 5) {				fprintf(stderr, "%s: too many args with %s/n",					progname, iflag);				exit(1);#endif	/* WEIRD_LIMITS */			replpos = srealloc(replpos,					(replsiz += 5) * sizeof *replpos);		}		replpos[replcnt++] = a_cnt;	}	a_vec[a_cnt++] = s;	a_asz += strlen(s) + 1;}static voidendcmd(void){	a_agg = a_cnt;	a_maxsize = sysconf(_SC_ARG_MAX) - envsz() - 2048 - a_asz;	if (nflag || sflag) {		long	newsize = sflag ? atol(sflag) :#ifdef	WEIRD_LIMITS			LINE_MAX;#else	/* !WEIRD_LIMITS */			a_maxsize;#endif	/* !WEIRD_LIMITS */		if (sflag && (newsize <= a_asz || newsize > a_maxsize))			fprintf(stderr,				"%s: 0 < max-cmd-line-size <= %ld: -s%s/n",				progname, a_maxsize, sflag);		if (newsize < a_maxsize)			a_maxsize = newsize;	}	if (sflag)		a_spc = smalloc(a_maxsize);	else {		while ((a_spc = malloc(a_maxsize)) == NULL) {			a_maxsize /= 2;			if (a_maxsize < LINE_MAX) {				a_spc = smalloc(a_maxsize);				break;			}		}	}	a_cur = a_agg;	if (nflag && nflag < a_maxarg + a_cnt) {		nflag += a_cnt;		a_maxarg = nflag;	}}

static int new_return_error(struct rtrn** ret, const char* err, int arg){    int r=-2;    int i=0;    const char** tmpv;    int* tmparg;    while ((*ret)->errsv[i++]);    (*ret)->errsc=i;    tmpv = srealloc((*ret)->errsv, (sizeof *(*ret)->errsv)*(i+1));    if (tmpv)    {        r++;        (*ret)->errsv=tmpv;        (*ret)->errsv[i-1]=err;        (*ret)->errsv[i]=NULL;    }    tmparg = srealloc((*ret)->errsarg, (sizeof *(*ret)->errsarg)*i);    if (tmparg)    {        r++;        (*ret)->errsarg=tmparg;        (*ret)->errsarg[i-1]=arg;    }    return r;}

static char *printer_add_enum(int param, char *buffer,                              int offset, int *nprinters_ptr){    DWORD needed, nprinters;    buffer = srealloc(buffer, offset+512);    /*     * Exploratory call to EnumPrinters to determine how much space     * we'll need for the output. Discard the return value since it     * will almost certainly be a failure due to lack of space.     */    EnumPrinters(param, NULL, ENUM_LEVEL, buffer+offset, 512,		 &needed, &nprinters);    if (needed < 512)        needed = 512;    buffer = srealloc(buffer, offset+needed);    if (EnumPrinters(param, NULL, ENUM_LEVEL, buffer+offset,                     needed, &needed, &nprinters) == 0)        return NULL;    *nprinters_ptr += nprinters;    return buffer;}

unsigned vector_grow(DV_Vector* dv){	unsigned old_max = dv->size_hint;	dv->size_hint *= 2;	dv->data = srealloc(dv->data, 			    dv->chunk_size * dv->size_hint);	dv->indices = srealloc(dv->indices, sizeof(unsigned) * dv->size_hint);	memset(dv->indices+old_max, 0, sizeof(unsigned)*old_max);	return dv->size_hint - old_max;}

void mat_resize(Matrix *m, int nrows, int ncols) {  int i;  if (!(nrows >= 0 && ncols >= 0))    die("ERROR mat_resize: nrows=%i ncols=%i/n", nrows, ncols);  for (i = nrows; i < m->nrows; i++) sfree(m->data[i]);  m->data = srealloc(m->data, nrows * sizeof(void*));  for (i = 0; i < nrows; i++)    m->data[i] = srealloc(m->data[i], ncols * sizeof(double));        m->nrows = nrows;  m->ncols = ncols;}

/* read in a tree from a file.  Return character string   representing tree */SEXP rph_tree_read(SEXP filename) {  FILE *infile;  char c;  SEXP result;  char *currStr, **strvec;  int i, pos=0, currLen=10000, numparen=0, numtrees_alloc=1000, numtrees=0;  infile = phast_fopen(CHARACTER_VALUE(filename), "r");  currStr = smalloc((currLen+2)*sizeof(char));  strvec = smalloc(numtrees_alloc*sizeof(char*));  while (1) {    pos=0;    numparen=0;    while (';'!=(c=fgetc(infile))) {      if (c==EOF) {	if (pos==0) break;	die("unexpected EOF in tree file.  Trees should be terminated by /";/"");      }      if (isspace(c)) continue;      if (c=='(') numparen++;      if (c==')') numparen--;      if (numparen < 0) die("bad tree in tree file");      if (pos==currLen) {	currLen += 10000;	currStr = srealloc(currStr, (currLen+2)*sizeof(char));      }      currStr[pos++] = c;    }    if (pos > 0) {      if (numparen != 0) die("unbalanced parenthesis in tree file");      currStr[pos++]=';';      currStr[pos]='/0';      if (numtrees == numtrees_alloc) {	numtrees_alloc += 1000;	strvec = srealloc(strvec, numtrees_alloc*sizeof(char*));      }      strvec[numtrees] = smalloc((strlen(currStr)+1)*sizeof(char));      strcpy(strvec[numtrees], currStr);      numtrees++;    }    else break;  }  phast_fclose(infile);  PROTECT(result = NEW_CHARACTER(numtrees));  for (i=0; i<numtrees; i++)    SET_STRING_ELT(result, i, mkChar(strvec[i]));  UNPROTECT(1);  return result;}

static int give_value(const char* val, struct option* opt){    int r=0;    unsigned short i=0;    if (opt->takes_value == 1)    {        free(opt->value);        opt->value = smalloc((sizeof *opt->value) * (strlen(val)+1));        if (opt->value)            strcpy(opt->value, val);        else            r=-1;    }    else    {        char** tmp;        while (opt->valuev[i++]);        tmp = srealloc(opt->valuev, (sizeof *opt->valuev)*(i+1));        if (tmp)        {            opt->valuev=tmp;            (opt->valuev)[i-1] = smalloc((sizeof *(opt->valuev)[i-1]) * (strlen(val)+1));            if ((opt->valuev)[i-1])                strcpy((opt->valuev)[i-1], val);            else                r=-1;            (opt->valuev)[i]=NULL;            opt->valuec=i;        }        else            r=-1;    }    return r;}

static bool opensex_read_next_row(database_handle_t *hdl){	int c = 0;	unsigned int n = 0;	opensex_t *rs = (opensex_t *)hdl->priv;	while ((c = getc(rs->f)) != EOF && c != '/n')	{		rs->buf[n++] = c;		if (n == rs->bufsize)		{			rs->bufsize *= 2;			rs->buf = srealloc(rs->buf, rs->bufsize);		}	}	rs->buf[n] = '/0';	rs->token = rs->buf;	if (c == EOF && ferror(rs->f))	{		slog(LG_ERROR, "opensex-read-next-row: error at %s line %d: %s", hdl->file, hdl->line, strerror(errno));		slog(LG_ERROR, "opensex-read-next-row: exiting to avoid data loss");		exit(EXIT_FAILURE);	}	if (c == EOF && n == 0)		return false;	hdl->line++;	hdl->token = 0;	return true;}

int split_buf(char *buf, char ***argv, int colon_special){    int argvsize = 8;    int argc;    char *s;    *argv = scalloc(sizeof(char *) * argvsize, 1);    argc = 0;    while (*buf) {        if (argc == argvsize) {            argvsize += 8;            *argv = srealloc(*argv, sizeof(char *) * argvsize);        }        if (*buf == ':') {            (*argv)[argc++] = buf + 1;            buf = "";        } else {            s = strpbrk(buf, " ");            if (s) {                *s++ = 0;                while (*s == ' ')                    s++;            } else {                s = buf + strlen(buf);            }            (*argv)[argc++] = buf;            buf = s;        }    }    return argc;}

void add_file(unsigned long long mult, char *name) {	unsigned int i;	file_t *file = NULL;	char *buffer = NULL;	// find matching entry in file_list	for (i=0; i < file_list_len; i++) {		file = &(file_list[i]);		if (strcmp(file->name, name) == 0) {			// is mult a multiple of file->mult?			if (mult % file->mult == 0)				return;			// is file->mult a multiple of mult?			if (file->mult % mult == 0) {				file->mult = mult;				return;			}			buffer = file->buffer;		}	}	// no buffer for file found?	if (!buffer)		buffer = (char *) smalloc(buflen);	// add new entry	file_list_len++;	file_list = (file_t *) srealloc((void *) file_list, sizeof(file_t) * file_list_len);	file = &(file_list[file_list_len - 1]);	file->mult = mult;	file->name = (char *) smalloc(strlen(name) + 1);	strcpy(file->name, name);	file->buffer = buffer;}

static void xmlrpc_command_success_nodata(sourceinfo_t *si, const char *message){    connection_t *cptr;    struct httpddata *hd;    char *p;    const char *q;    cptr = si->connection;    hd = cptr->userdata;    if (hd->sent_reply)        return;    if (hd->replybuf != NULL)    {        hd->replybuf = srealloc(hd->replybuf, strlen(hd->replybuf) + strlen(message) + 2);        p = hd->replybuf + strlen(hd->replybuf);        *p++ = '/n';    }    else    {        hd->replybuf = smalloc(strlen(message) + 1);        p = hd->replybuf;    }    q = message;    while (*q != '/0')        if (*q > '/0' && *q < ' ')            q++;        else            *p++ = *q++;    *p = '/0';}

inline int FindTimerSpace() {	for (int i = 0; i<numTimers; i++) {		if (timers[i].type == KILLED_TIMER) return i;	}	if (!srealloc(timers, sizeof(ScriptTimer) * (numTimers+1))) return -1;	return numTimers ++;}

void string::set_length(int i){  assert(i >= 0);  if (i > sz)    ptr = srealloc(ptr, sz, len, i, &sz);  len = i;}

void addtest(void *elem) {    int i, j;    void *retval, *realret;    if (arraysize < arraylen+1) {        arraysize = arraylen+1+256;        array = (array == NULL ? smalloc(arraysize*sizeof(*array)) :                 srealloc(array, arraysize*sizeof(*array)));    }    i = 0;    while (i < arraylen && cmp(elem, array[i]) > 0)        i++;    /* now i points to the first element >= elem */    if (i < arraylen && !cmp(elem, array[i]))        retval = array[i];             /* expect that returned not elem */    else {        retval = elem;                  /* expect elem returned (success) */        for (j = arraylen; j > i; j--)            array[j] = array[j-1];        array[i] = elem;                /* add elem to array */        arraylen++;    }    realret = add234(tree, elem);    if (realret != retval) {        error("add: retval was %p expected %p", realret, retval);    }    verify();}

static int sftp_cmd_lcd(struct sftp_command *cmd){    char *currdir;    int len;    if (cmd->nwords < 2) {	printf("lcd: expects a local directory name/n");	return 0;    }    if (!SetCurrentDirectory(cmd->words[1])) {	LPVOID message;	int i;	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |		      FORMAT_MESSAGE_FROM_SYSTEM |		      FORMAT_MESSAGE_IGNORE_INSERTS,		      NULL, GetLastError(),		      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),		      (LPTSTR)&message, 0, NULL);	i = strcspn((char *)message, "/n");	printf("lcd: unable to change directory: %.*s/n", i, (LPCTSTR)message);	LocalFree(message);	return 0;    }    currdir = smalloc(256);    len = GetCurrentDirectory(256, currdir);    if (len > 256)	currdir = srealloc(currdir, len);    GetCurrentDirectory(len, currdir);    printf("New local directory is %s/n", currdir);    sfree(currdir);    return 1;}

static void opl_append(struct oplist *o, enum optype type){	if (o->len == o->size)	{		o->size += o->size >> 1;		o->ops = srealloc(o->ops, o->size * sizeof *o->ops);	}

static void xmlrpc_command_success_nodata(sourceinfo_t *si, const char *message){	connection_t *cptr;	struct httpddata *hd;	char *newmessage;	char *p;	newmessage = xmlrpc_normalizeBuffer(message);	cptr = si->connection;	hd = cptr->userdata;	if (hd->sent_reply)	{		free(newmessage);		return;	}	if (hd->replybuf != NULL)	{		hd->replybuf = srealloc(hd->replybuf, strlen(hd->replybuf) + strlen(newmessage) + 2);		p = hd->replybuf + strlen(hd->replybuf);		*p++ = '/n';	}	else	{		hd->replybuf = smalloc(strlen(newmessage) + 1);		p = hd->replybuf;	}        strcpy(p, newmessage);	free(newmessage);}

int find_side_bndy (    struct vtx_data **graph,	/* array of vtx data for graph */    int nvtxs,		/* number of vertices in graph */    int *assignment,		/* processor each vertex gets assigned to */    int side,			/* side to take vertices from */    int new_val,		/* assignment value for boundary vtxs */    int **pbndy_list		/* returned list, end with zero */){    int      *edges;		/* loops through edge list */    int      *bndy_list;	/* returned list, end with zero */    int       list_length;	/* returned number of vtxs on boundary */    int       set, set2;	/* set a vertex is in */    int       i, j;		/* loop counters */    if (*pbndy_list != NULL) {	/* Contains list of all vertices on boundary. */	bndy_list = *pbndy_list;	i = list_length = 0;	while (bndy_list[i] != 0) {	    if (assignment[bndy_list[i]] == side) {		bndy_list[list_length++] = bndy_list[i];	    }	    ++i;	}    }    else {	bndy_list = smalloc((nvtxs + 1) * sizeof(int));	list_length = 0;	for (i = 1; i <= nvtxs; i++) {	    set = assignment[i];	    if (set == side) {		edges = graph[i]->edges;		for (j = graph[i]->nedges - 1; j; j--) {		    set2 = assignment[*(++edges)];		    if (set2 != set) {			bndy_list[list_length++] = i;			break;		    }		}	    }	}    }    bndy_list[list_length] = 0;    for (i = 0; i < list_length; i++) {	assignment[bndy_list[i]] = (int) new_val;    }    /* Shrink out unnecessary space */    *pbndy_list = srealloc(bndy_list, (list_length + 1) * sizeof(int));    return (list_length);}

/* debug realloc: srealloc() with memory management */void *d_realloc( void *oldptr, size_t newsize ){	void *p = srealloc( oldptr, newsize );		clog( CL_DEBUG, "srealloc(%p,%d) -> %p", oldptr, newsize, p );		return p;}

static voidsetlevel(int level, struct getdb *db, int fd){	if (level >= maxlevel)		levels = srealloc(levels, (maxlevel=level+16) * sizeof *levels);	levels[level].l_db = db;	levels[level].l_fd = fd;}

/* conditioned_on must be an array of integer lists; specifically, the   ith element must be the list of state numbers on which the ith   state is conditioned. */Unspooler *cm_create_unspooler(int nstates_spooled, List **conditioned_on) {  UnspoolNode *n;  int i, j;  Stack *s;  Unspooler *unsp;  int *mark;  int capacity;  unsp = (Unspooler*)smalloc(sizeof(Unspooler));  unsp->nstates_spooled = nstates_spooled;  unsp->nstates_unspooled = 0;  unsp->spooled_to_unspooled =     (UnspoolNode**)smalloc(nstates_spooled * sizeof(UnspoolNode*));  capacity = nstates_spooled * nstates_spooled;  unsp->unspooled_to_spooled = (int*)smalloc(capacity * sizeof(int));  mark = (int*)smalloc(nstates_spooled * sizeof(int));  s = stk_new_ptr(nstates_spooled);  for (i = 0; i < nstates_spooled; i++) {    /* erase marks (used to detect cycles) */    for (j = 0; j < nstates_spooled; j++) mark[j] = 0;    unsp->spooled_to_unspooled[i] = cm_new_unspool_node(i);    stk_push_ptr(s, unsp->spooled_to_unspooled[i]);    while ((n = (UnspoolNode*)stk_pop_ptr(s)) != NULL) {      if (conditioned_on[n->oldstate] == NULL ||          lst_size(conditioned_on[n->oldstate]) == 0) {        n->newstate = unsp->nstates_unspooled++;        /* mapping to spooled space */        if (n->newstate >= capacity) {          capacity *= 2;          unsp->unspooled_to_spooled =             (int*)srealloc(unsp->unspooled_to_spooled,                           capacity * sizeof(int));                  }        unsp->unspooled_to_spooled[n->newstate] = i;      }      else {        for (j = 0; j < lst_size(conditioned_on[n->oldstate]); j++) {          int oldstate = lst_get_int(conditioned_on[n->oldstate], j);          UnspoolNode *m;          if (mark[oldstate] == 1)            die("ERROR: cycle in 'conditioned_on' dependencies./n");          mark[oldstate] = 1;          m = cm_new_unspool_node(oldstate);          lst_push_ptr(n->children, m);          stk_push_ptr(s, m);        }      }    }  }  stk_free(s);  sfree(mark);  return unsp;}

void headpreheader(struct hthead *head, const char *name, const char *val){    head->headers = srealloc(head->headers, sizeof(*head->headers) * (head->noheaders + 1));    memmove(head->headers + 1, head->headers, sizeof(*head->headers) * head->noheaders);    head->noheaders++;    head->headers[0] = smalloc(sizeof(*head->headers[0]) * 2);    head->headers[0][0] = sstrdup(name);    head->headers[0][1] = sstrdup(val);}

static voidsetppi(int f, long j, const char *p){    if (j >= ppisize[f]) {        ppisize[f] = j + 1;        ppibuf[f] = srealloc(ppibuf[f], ppisize[f] * sizeof *ppibuf[f]);    }    ppibuf[f][j] = p;}

/* Reallocate a category map to allow for the specified size. */void cm_realloc(CategoryMap *cm, int new_ncats) {  int i;  int old_ncats = cm->ncats;  cm->ncats = new_ncats;  cm->ranges = srealloc(cm->ranges, (cm->ncats + 1) * sizeof(CategoryRange*));  cm->conditioned_on = srealloc(cm->conditioned_on,                                (cm->ncats + 1) * sizeof(List*));  cm->labelling_precedence = srealloc(cm->labelling_precedence,                                      (cm->ncats + 1) * sizeof(int));  cm->fill_precedence = srealloc(cm->fill_precedence,                                 (cm->ncats + 1) * sizeof(int));  for (i = old_ncats+1; i <= cm->ncats; i++) {    cm->ranges[i] = NULL;    cm->conditioned_on[i] = NULL;    cm->labelling_precedence[i] = -1;    cm->fill_precedence[i] = -1;  }}

void string::append(const char *p, int n){  if (n > 0) {    int newlen = len + n;    if (newlen > sz)      ptr = srealloc(ptr, sz, len, newlen, &sz);    memcpy(ptr + len, p, n);    len = newlen;  }}

void headappheader(struct hthead *head, const char *name, const char *val){    int i;    i = head->noheaders++;    head->headers = srealloc(head->headers, sizeof(*head->headers) * head->noheaders);    head->headers[i] = smalloc(sizeof(*head->headers[i]) * 2);    head->headers[i][0] = sstrdup(name);    head->headers[i][1] = sstrdup(val);}

static int read_qseq_line(FILE *f, char *fname, char *fields[11]) {  static const char *spaces = " /t/n";  static char       *buffer = NULL;  static size_t      bufsz = 0;  size_t             s;  char              *b;  char              *res;  int                i;  if (NULL == buffer) {    bufsz = 1024;    buffer = smalloc(bufsz);  }  b = buffer;  s = bufsz;  b[s - 1] = '*';  while (NULL != (res = fgets(b, s, f))) {    if (b[s - 1] == 0 && b[s - 2] != '/n') {      bufsz *= 2;      buffer = srealloc(buffer, bufsz);      b = buffer + s - 1;      s = bufsz - (b - buffer);      b[s - 1] = '*';    } else {      break;    }  }  if (NULL == res) {    if (ferror(f)) {      printf("Error reading %s: %s/n", fname, strerror(errno));      return -1;    } else { /* eof */      return 1;    }  }  /* (*line_no)++; */    b = buffer;  s = 0;  for (i = 0; i < 11; i++) {    fields[i] = buffer + s;    s += strcspn(buffer + s, spaces);    if (buffer[s] == '/0') {      printf("Error reading qseq file: not enough fields found/n");      return -1;    }    buffer[s++] = '/0';    s += strspn(buffer + s, spaces);  }  return 0;}

/* Get administrators of the groups */static int get_groupadmins(void){	FILE *f;	int line = 0;	char buffer[IOBUF_SIZE], *colpos, *grouppos, *endname, *adminpos;	if (!(f = fopen(adminsfile, "r"))) {		errstr(_("Cannot open file with group administrators: %s/n"), strerror(errno));		return -1;	}		while (fgets(buffer, IOBUF_SIZE, f)) {		line++;		if (buffer[0] == ';' || buffer[0] == '#')			continue;		/* Skip initial spaces */		for (colpos = buffer; isspace(*colpos); colpos++);		if (!*colpos)	/* Empty line? */			continue;		/* Find splitting colon */		for (grouppos = colpos; *colpos && *colpos != ':'; colpos++);		if (!*colpos || grouppos == colpos) {			errstr(_("Parse error at line %d. Cannot find end of group name./n"), line);			continue;		}		/* Cut trailing spaces */		for (endname = colpos-1; isspace(*endname); endname--);		*(++endname) = 0;		/* Skip initial spaces at admins name */		for (colpos++; isspace(*colpos); colpos++);		if (!*colpos) {			errstr(_("Parse error at line %d. Cannot find administrators name./n"), line);			continue;		}		/* Go through admins name */		for (adminpos = colpos; !isspace(*colpos); colpos++);		if (*colpos) {	/* Some characters after name? */			*colpos = 0;			/* Skip trailing spaces */			for (colpos++; isspace(*colpos); colpos++);			if (*colpos) {				errstr(_("Parse error at line %d. Trailing characters after administrators name./n"), line);				continue;			}		}		if (adminscnt >= adminsalloc)			adminstable = srealloc(adminstable, sizeof(struct adminstable)*(adminsalloc+=ADMIN_TAB_ALLOC));		adminstable[adminscnt].grpname = sstrdup(grouppos);		adminstable[adminscnt++].adminname = sstrdup(adminpos);	}	fclose(f);	qsort(adminstable, adminscnt, sizeof(struct adminstable), admin_cmp);	return 0;}