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

void grep_source_clear(struct grep_source *gs){	FREE_AND_NULL(gs->name);	FREE_AND_NULL(gs->path);	FREE_AND_NULL(gs->identifier);	grep_source_clear_data(gs);}

int modem_close(void){	time_t start;	conn_api.terminate=1;	if((comGetModemStatus(com)&COM_DCD)==0)	/* DCD already low */		goto CLOSEIT;	/* TODO:  We need a drain function */	SLEEP(500);	if(!comLowerDTR(com))		goto CLOSEIT;	start=time(NULL);	while(time(NULL)-start <= 10) {		if((comGetModemStatus(com)&COM_DCD) == 0)			goto CLOSEIT;		SLEEP(1000); 	}CLOSEIT:	while(conn_api.input_thread_running || conn_api.output_thread_running)		SLEEP(1);	comClose(com);	destroy_conn_buf(&conn_inbuf);	destroy_conn_buf(&conn_outbuf);	FREE_AND_NULL(conn_api.rd_buf);	FREE_AND_NULL(conn_api.wr_buf);	return(0);}

void signature_check_clear(struct signature_check *sigc){	FREE_AND_NULL(sigc->payload);	FREE_AND_NULL(sigc->gpg_output);	FREE_AND_NULL(sigc->gpg_status);	FREE_AND_NULL(sigc->signer);	FREE_AND_NULL(sigc->key);}

void refspec_item_clear(struct refspec_item *item){	FREE_AND_NULL(item->src);	FREE_AND_NULL(item->dst);	item->force = 0;	item->pattern = 0;	item->matching = 0;	item->exact_sha1 = 0;}

void repo_clear(struct repository *repo){	FREE_AND_NULL(repo->gitdir);	FREE_AND_NULL(repo->commondir);	FREE_AND_NULL(repo->graft_file);	FREE_AND_NULL(repo->index_file);	FREE_AND_NULL(repo->worktree);	FREE_AND_NULL(repo->submodule_prefix);	raw_object_store_clear(repo->objects);	FREE_AND_NULL(repo->objects);	if (repo->config) {		git_configset_clear(repo->config);		FREE_AND_NULL(repo->config);	}	if (repo->submodule_cache) {		submodule_cache_free(repo->submodule_cache);		repo->submodule_cache = NULL;	}	if (repo->index) {		discard_index(repo->index);		FREE_AND_NULL(repo->index);	}}

void attr_check_clear(struct attr_check *check){	FREE_AND_NULL(check->items);	check->alloc = 0;	check->nr = 0;	FREE_AND_NULL(check->all_attrs);	check->all_attrs_nr = 0;	drop_attr_stack(&check->stack);}

int serial_close(void){	conn_api.terminate=1;	while(conn_api.input_thread_running || conn_api.output_thread_running)		SLEEP(1);	comClose(com);	destroy_conn_buf(&conn_inbuf);	destroy_conn_buf(&conn_outbuf);	FREE_AND_NULL(conn_api.rd_buf);	FREE_AND_NULL(conn_api.wr_buf);	return(0);}

void credential_reject(struct credential *c){	int i;	credential_apply_config(c);	for (i = 0; i < c->helpers.nr; i++)		credential_do(c, c->helpers.items[i].string, "erase");	FREE_AND_NULL(c->username);	FREE_AND_NULL(c->password);	c->approved = 0;}

/*--------------------------------------------------------------------------- gamma.c (destroy_rules)----------------------------------------------------------------------------*/void destroy_rules( RULE_PARAM * r_p ) {    if ( r_p != NULL ) {      DBG("destroy_rules 1");      FREE_AND_NULL( r_p -> rule_space ) ;      DBG("destroy_rules 2");      FREE_AND_NULL( r_p -> key_space ) ;      DBG("destroy_rules 3");      PAGC_DESTROY_2D_ARRAY(r_p->output_link,KW*,r_p->num_nodes) ;      DBG("destroy_rules 4");      PAGC_DESTROY_2D_ARRAY(r_p->gamma_matrix,NODE,r_p->num_nodes) ;      DBG(" destroy_rules 5");      FREE_AND_NULL( r_p ) ;   }

void raw_object_store_clear(struct raw_object_store *o){	FREE_AND_NULL(o->objectdir);	FREE_AND_NULL(o->alternate_db);	oidmap_free(o->replace_map, 1);	FREE_AND_NULL(o->replace_map);	free_alt_odbs(o);	o->alt_odb_tail = NULL;	INIT_LIST_HEAD(&o->packed_git_mru);	close_all_packs(o);	o->packed_git = NULL;}

static void fetch_symref(const char *path, char **symref, struct object_id *oid){	char *url = xstrfmt("%s%s", repo->url, path);	struct strbuf buffer = STRBUF_INIT;	const char *name;	if (http_get_strbuf(url, &buffer, NULL) != HTTP_OK)		die("Couldn't get %s for remote symref/n%s", url,		    curl_errorstr);	free(url);	FREE_AND_NULL(*symref);	oidclr(oid);	if (buffer.len == 0)		return;	/* Cut off trailing newline. */	strbuf_rtrim(&buffer);	/* If it's a symref, set the refname; otherwise try for a sha1 */	if (skip_prefix(buffer.buf, "ref: ", &name)) {		*symref = xmemdupz(name, buffer.len - (name - buffer.buf));	} else {		get_oid_hex(buffer.buf, oid);	}	strbuf_release(&buffer);}

static voidxml_start_tag(void *userData, const char *name, const char **atts){	struct xml_ctx *ctx = (struct xml_ctx *)userData;	const char *c = strchr(name, ':');	int old_namelen, new_len;	if (c == NULL)		c = name;	else		c++;	old_namelen = strlen(ctx->name);	new_len = old_namelen + strlen(c) + 2;	if (new_len > ctx->len) {		ctx->name = xrealloc(ctx->name, new_len);		ctx->len = new_len;	}	xsnprintf(ctx->name + old_namelen, ctx->len - old_namelen, ".%s", c);	FREE_AND_NULL(ctx->cdata);	ctx->userFunc(ctx, 0);}

static voidpylzma_decomp_dealloc(CDecompressionObject *self){    LzmaDec_Free(&self->state, &allocator);    FREE_AND_NULL(self->unconsumed_tail);    self->ob_type->tp_free((PyObject*) self);}

static int graph_verify(int argc, const char **argv){	struct commit_graph *graph = NULL;	char *graph_name;	static struct option builtin_commit_graph_verify_options[] = {		OPT_STRING(0, "object-dir", &opts.obj_dir,			   N_("dir"),			   N_("The object directory to store the graph")),		OPT_END(),	};	argc = parse_options(argc, argv, NULL,			     builtin_commit_graph_verify_options,			     builtin_commit_graph_verify_usage, 0);	if (!opts.obj_dir)		opts.obj_dir = get_object_directory();	graph_name = get_commit_graph_filename(opts.obj_dir);	graph = load_commit_graph_one(graph_name);	FREE_AND_NULL(graph_name);	if (!graph)		return 0;	UNLEAK(graph);	return verify_commit_graph(the_repository, graph);}

/* * Make a new combine_diff_path from path/mode/sha1 * and append it to paths list tail. * * Memory for created elements could be reused: * *	- if last->next == NULL, the memory is allocated; * *	- if last->next != NULL, it is assumed that p=last->next was returned *	  earlier by this function, and p->next was *not* modified. *	  The memory is then reused from p. * * so for clients, * * - if you do need to keep the element * *	p = path_appendnew(p, ...); *	process(p); *	p->next = NULL; * * - if you don't need to keep the element after processing * *	pprev = p; *	p = path_appendnew(p, ...); *	process(p); *	p = pprev; *	; don't forget to free tail->next in the end * * p->parent[] remains uninitialized. */static struct combine_diff_path *path_appendnew(struct combine_diff_path *last,	int nparent, const struct strbuf *base, const char *path, int pathlen,	unsigned mode, const struct object_id *oid){	struct combine_diff_path *p;	size_t len = st_add(base->len, pathlen);	size_t alloclen = combine_diff_path_size(nparent, len);	/* if last->next is !NULL - it is a pre-allocated memory, we can reuse */	p = last->next;	if (p && (alloclen > (intptr_t)p->next)) {		FREE_AND_NULL(p);	}	if (!p) {		p = xmalloc(alloclen);		/*		 * until we go to it next round, .next holds how many bytes we		 * allocated (for faster realloc - we don't need copying old data).		 */		p->next = (struct combine_diff_path *)(intptr_t)alloclen;	}	last->next = p;	p->path = (char *)&(p->parent[nparent]);	memcpy(p->path, base->buf, base->len);	memcpy(p->path + base->len, path, pathlen);	p->path[len] = 0;	p->mode = mode;	oidcpy(&p->oid, oid ? oid : &null_oid);	return p;}

static void pylzma_decomp_dealloc(CCompatDecompressionObject *self){    free_lzma_stream(&self->stream);    FREE_AND_NULL(self->unconsumed_tail);    DEC_AND_NULL(self->unused_data);    PyObject_Del(self);}

/* ------------------------------------------------------------err_param.c (init_errors) :calls : err_param.c (open_error_log), stdlib.h (malloc, free) ,stdio.h (fprintf, fflush) stdlib.h (malloc,free)--------------------------------------------------------------*/ERR_PARAM *init_errors( PAGC_GLOBAL *pagc_glo_p ,                        const char *log_name ) {   ERR_PARAM *err_p ;   ERR_REC *err_mem ;   err_p = ( ERR_PARAM * ) malloc( sizeof( ERR_PARAM ) ) ;   if ( err_p == NULL ) {#ifndef NO_STDERR_OUTPUT      PRINT_ERROR( "%s/n" ,                   "FATAL ERROR : Could not allocate memory for pagc_init_errors" ) ;#endif      return NULL ;   }   /* -- set up first record -- */   RESET_ERR_P ;   /* -- a null log_name means we don't log , but collect -- */   if ( log_name == NULL ) {      err_p -> stream = NULL ;   }   else {      err_p -> stream = open_error_log( log_name ,                                        pagc_glo_p -> _file_sys ,                                        err_p ) ;      if ( err_p -> stream == NULL ) {         FREE_AND_NULL( err_p ) ;#ifndef NO_STDERR_OUTPUT         PRINT_ERROR( "Could not create error log for pathname: %s/n" ,                       log_name ) ;#endif         return NULL ;      }                     }   return err_p ;}   

/* ------------------------------------------------------------err_param.c (close_errors)uses macros BLANK_STRING, FREE_AND_NULL, and PRINT_ERROR--------------------------------------------------------------*/void close_errors( ERR_PARAM *err_p ) {   int is_fatal_error ;   char err_out_buf[ MAXSTRLEN ] ;   if ( err_p == NULL ) {      return ;   }   BLANK_STRING( err_out_buf ) ;   /* -- read each error into the buffer and then      output it as a single line -- */   while ( empty_errors( err_p ,                         &is_fatal_error ,                         err_out_buf ) ) {      if ( is_fatal_error ) {#ifndef NO_STDERR_OUTPUT         PRINT_ERROR( "ERROR: %s/n" ,                      err_out_buf ) ;      } else {         PRINT_ERROR( "%s/n" ,                      err_out_buf ) ;#endif      }      BLANK_STRING( err_out_buf ) ;   }       FREE_AND_NULL( err_p ) ;}

void oid_array_clear(struct oid_array *array){	FREE_AND_NULL(array->oid);	array->nr = 0;	array->alloc = 0;	array->sorted = 0;}

void strListFree(str_list_t* list){	if(*list!=NULL) {		strListFreeStrings(*list);		FREE_AND_NULL(*list);	}}

/* * User defined low-level merge driver support. */static int ll_ext_merge(const struct ll_merge_driver *fn,			mmbuffer_t *result,			const char *path,			mmfile_t *orig, const char *orig_name,			mmfile_t *src1, const char *name1,			mmfile_t *src2, const char *name2,			const struct ll_merge_options *opts,			int marker_size){	char temp[4][50];	struct strbuf cmd = STRBUF_INIT;	struct strbuf_expand_dict_entry dict[6];	struct strbuf path_sq = STRBUF_INIT;	const char *args[] = { NULL, NULL };	int status, fd, i;	struct stat st;	assert(opts);	sq_quote_buf(&path_sq, path);	dict[0].placeholder = "O"; dict[0].value = temp[0];	dict[1].placeholder = "A"; dict[1].value = temp[1];	dict[2].placeholder = "B"; dict[2].value = temp[2];	dict[3].placeholder = "L"; dict[3].value = temp[3];	dict[4].placeholder = "P"; dict[4].value = path_sq.buf;	dict[5].placeholder = NULL; dict[5].value = NULL;	if (fn->cmdline == NULL)		die("custom merge driver %s lacks command line.", fn->name);	result->ptr = NULL;	result->size = 0;	create_temp(orig, temp[0], sizeof(temp[0]));	create_temp(src1, temp[1], sizeof(temp[1]));	create_temp(src2, temp[2], sizeof(temp[2]));	xsnprintf(temp[3], sizeof(temp[3]), "%d", marker_size);	strbuf_expand(&cmd, fn->cmdline, strbuf_expand_dict_cb, &dict);	args[0] = cmd.buf;	status = run_command_v_opt(args, RUN_USING_SHELL);	fd = open(temp[1], O_RDONLY);	if (fd < 0)		goto bad;	if (fstat(fd, &st))		goto close_bad;	result->size = st.st_size;	result->ptr = xmallocz(result->size);	if (read_in_full(fd, result->ptr, result->size) != result->size) {		FREE_AND_NULL(result->ptr);		result->size = 0;	} close_bad:	close(fd); bad:	for (i = 0; i < 3; i++)		unlink_or_warn(temp[i]);	strbuf_release(&cmd);	strbuf_release(&path_sq);	return status;}

void transport_unlock_pack(struct transport *transport){	if (transport->pack_lockfile) {		unlink_or_warn(transport->pack_lockfile);		FREE_AND_NULL(transport->pack_lockfile);	}}

static void *get_data(unsigned long size){	git_zstream stream;	void *buf = xmallocz(size);	memset(&stream, 0, sizeof(stream));	stream.next_out = buf;	stream.avail_out = size;	stream.next_in = fill(1);	stream.avail_in = len;	git_inflate_init(&stream);	for (;;) {		int ret = git_inflate(&stream, 0);		use(len - stream.avail_in);		if (stream.total_out == size && ret == Z_STREAM_END)			break;		if (ret != Z_OK) {			error("inflate returned %d", ret);			FREE_AND_NULL(buf);			if (!recover)				exit(1);			has_errors = 1;			break;		}		stream.next_in = fill(1);		stream.avail_in = len;	}	git_inflate_end(&stream);	return buf;}

BOOL read_attr_cfg(scfg_t* cfg, char* error){	char*	p;    char    str[256],fname[13];	long	offset=0;    FILE    *instream;	strcpy(fname,"attr.cfg");	sprintf(str,"%s%s",cfg->ctrl_dir,fname);	if((instream=fnopen(NULL,str,O_RDONLY))==NULL) {		sprintf(error,"%d opening %s",errno,str);		return(FALSE); 	}	FREE_AND_NULL(cfg->color);	if((cfg->color=malloc(MIN_COLORS))==NULL) {		sprintf(error,"Error allocating memory (%u bytes) for colors"			,MIN_COLORS);		return(FALSE);	}	memset(cfg->color,LIGHTGRAY|HIGH,MIN_COLORS);		for(cfg->total_colors=0;!feof(instream) && !ferror(instream);cfg->total_colors++) {		if(readline(&offset,str,4,instream)==NULL)			break;		if(cfg->total_colors>=MIN_COLORS) {			if((p=realloc(cfg->color,cfg->total_colors+1))==NULL)				break;			cfg->color=p;		}		cfg->color[cfg->total_colors]=attrstr(str); 	}	fclose(instream);	if(cfg->total_colors<MIN_COLORS)		cfg->total_colors=MIN_COLORS;	return(TRUE);}

void object_array_clear(struct object_array *array){	int i;	for (i = 0; i < array->nr; i++)		object_array_release_entry(&array->objects[i]);	FREE_AND_NULL(array->objects);	array->nr = array->alloc = 0;}

void free_node_cfg(scfg_t* cfg){	FREE_AR(cfg->node_ar);	if(cfg->mdm_result!=NULL) {		FREE_AND_NULL(cfg->mdm_result);	}}

/* * Clear and free all entries in dir, recursively. */static void clear_ref_dir(struct ref_dir *dir){	int i;	for (i = 0; i < dir->nr; i++)		free_ref_entry(dir->entries[i]);	FREE_AND_NULL(dir->entries);	dir->sorted = dir->nr = dir->alloc = 0;}

static void add_cmd_list(struct cmdnames *cmds, struct cmdnames *old){	int i;	ALLOC_GROW(cmds->names, cmds->cnt + old->cnt, cmds->alloc);	for (i = 0; i < old->cnt; i++)		cmds->names[cmds->cnt++] = old->names[i];	FREE_AND_NULL(old->names);	old->cnt = 0;}

static void free_rerere_dirs(void){	int i;	for (i = 0; i < rerere_dir_nr; i++) {		free(rerere_dir[i]->status);		free(rerere_dir[i]);	}	FREE_AND_NULL(rerere_dir);	rerere_dir_nr = rerere_dir_alloc = 0;}

void free_chat_cfg(scfg_t* cfg){	int i;	if(cfg->actset!=NULL) {		for(i=0;i<cfg->total_actsets;i++) {			FREE_AND_NULL(cfg->actset[i]);		}		FREE_AND_NULL(cfg->actset);	}	if(cfg->chatact!=NULL) {		for(i=0;i<cfg->total_chatacts;i++) {			FREE_AND_NULL(cfg->chatact[i]);		}		FREE_AND_NULL(cfg->chatact);	}	if(cfg->chan!=NULL) {		for(i=0;i<cfg->total_chans;i++) {			FREE_AR(cfg->chan[i]->ar);			FREE_AND_NULL(cfg->chan[i]);		}		FREE_AND_NULL(cfg->chan);	}	if(cfg->guru!=NULL) {		for(i=0;i<cfg->total_gurus;i++) {			FREE_AR(cfg->guru[i]->ar);			FREE_AND_NULL(cfg->guru[i]);		}		FREE_AND_NULL(cfg->guru);	}	if(cfg->page!=NULL) {		for(i=0;i<cfg->total_pages;i++) {			FREE_AR(cfg->page[i]->ar);			FREE_AND_NULL(cfg->page[i]);		}		FREE_AND_NULL(cfg->page);	}}