C++ release函数代码示例

	DisplayObject::~DisplayObject()
	{
		if (_parent != 0) {
			release(_parent);
		}
	}

Input::~Input() {
    stop();
    release();
    delete m_localFrame;
    delete m_listener;
}

QCLVectorBase::~QCLVectorBase()
{
    release();
}

	NE_DLL NEDebugManager::Flag::Flag()
		: NEObject()
	{
		release();
	}

tupp::~tupp()		// destructor
{
    // release the pointer before deallocating the space for it
    release();
}

/* Return bytes written, negative on error */
int swrite(rd_t rd, char* s) {
    if (rd < 0 || rd >= RESOURCE_TABLE_SIZE) {
        return -1;
    }

    int n = 0; 

    if (task_switching) {
        acquire(curr_task->task->resources[rd]->sem);
        if (curr_task->task->resources[rd]->swriter) {
            int ret = curr_task->task->resources[rd]->swriter(s, curr_task->task->resources[rd]->env);
            if (ret >= 0) {
                n += ret;
            }
            else {
                n = ret;
            }
                
        }
        else {
            while(*s) {
                int ret = curr_task->task->resources[rd]->writer(*s++, curr_task->task->resources[rd]->env);
                if (ret >= 0) {
                    n += ret;
                }
                else {
                    n = ret;
                    break;
                }
            }
        }
        release(curr_task->task->resources[rd]->sem);
    }
    else {
        if(default_resources[rd] != NULL) {
            if (default_resources[rd]->swriter) {
                int ret = default_resources[rd]->swriter(s, default_resources[rd]->env);
                if (ret >= 0) {
                    n += ret;
                }
                else {
                    n = ret;
                }
            }
            else {
                while(*s) {
                    int ret = default_resources[rd]->writer(*s++, default_resources[rd]->env);
                    if (ret >= 0) {
                        n += ret;
                    }
                    else {
                        n = ret;
                        break;
                    }
                }
            }
        }
        else { 
            return -1;
        }
    }

    return n;
}

 SDOXMLString::~SDOXMLString()
 {
     release();
 }

void* OPJSupport::decompressJPEG2KWithBuffer	( void* inputBuffer, void* jp2Data, long jp2DataSize, long *decompressedBufferSize, int *colorModel){
    opj_dparameters_t parameters;
	OPJ_BOOL hasFile = OPJ_FALSE;

	opj_buffer_info_t buf_info;
	int i, decod_format;
	int width, height;
	OPJ_BOOL hasAlpha, fails = OPJ_FALSE;
	OPJ_CODEC_FORMAT codec_format;
	unsigned char rc, gc, bc, ac;

	decode_info_t decodeInfo;


	memset(&decodeInfo, 0, sizeof(decode_info_t));
	memset(&buf_info, 0, sizeof(opj_buffer_info_t));

	if (jp2Data != NULL)
	{
		buf_info.len = jp2DataSize;
		buf_info.buf =  (OPJ_BYTE*)jp2Data;
		buf_info.cur = buf_info.buf;
	}


	opj_set_default_decoder_parameters(&parameters);
	decod_format = buffer_format(&buf_info);

	if(decod_format == -1)
	{
		fprintf(stderr,"%s:%d: decode format missing\n",__FILE__,__LINE__);
		release(&decodeInfo);
		return 0;
	}

	/*-----------------------------------------------*/
	if(decod_format == J2K_CFMT)
		codec_format = OPJ_CODEC_J2K;
	else
		if(decod_format == JP2_CFMT)
			codec_format = OPJ_CODEC_JP2;
		else
			if(decod_format == JPT_CFMT)
				codec_format = OPJ_CODEC_JPT;
			else
			{
				/* clarified in infile_format() : */
				release(&decodeInfo);
				return 0;
			}
    parameters.decod_format = decod_format;
    while(1)
    {
	int tile_index=-1, user_changed_tile=0, user_changed_reduction=0;
	int max_tiles=0, max_reduction=0;
	fails = OPJ_TRUE;
	decodeInfo.stream =  opj_stream_create_buffer_stream(&buf_info, 1);


	if(decodeInfo.stream == NULL)
	{
	    fprintf(stderr,"%s:%d: NO decodeInfo.stream\n",__FILE__,__LINE__);
	    break;
	}
	decodeInfo.codec = opj_create_decompress(codec_format);
	if(decodeInfo.codec == NULL)
	{
	    fprintf(stderr,"%s:%d: NO coded\n",__FILE__,__LINE__);
	    break;
	}

      //  opj_set_info_handler(decodeInfo.codec, error_callback, this);
      //  opj_set_info_handler(decodeInfo.codec, warning_callback, this);
      //  opj_set_info_handler(decodeInfo.codec, info_callback, this);

	if( !opj_setup_decoder(decodeInfo.codec, &parameters))
	{
	    fprintf(stderr,"%s:%d:\n\topj_setup_decoder failed\n",__FILE__,__LINE__);
	    break;
	}

	if(user_changed_tile && user_changed_reduction)
	{
	    int reduction=0;
	    opj_set_decoded_resolution_factor(decodeInfo.codec, reduction);
	}

	if( !opj_read_header(decodeInfo.stream, decodeInfo.codec, &decodeInfo.image))
	{
	    fprintf(stderr,"%s:%d:\n\topj_read_header failed\n",__FILE__,__LINE__);
	    break;
	}

	if( !(user_changed_tile && user_changed_reduction)
	   || (max_tiles <= 0) || (max_reduction <= 0) )
	{
	    opj_codestream_info_v2_t *cstr;

	    cstr = opj_get_cstr_info(decodeInfo.codec);

//.........这里部分代码省略.........

void run(void)
{
	data='w';
	while(1)
	{
		while(data == 'w') //waiting for signal
		{	
		}
		while(data == '\0' )
		{
			stop();
			_delay_ms(4000);
			comintersection();
			_delay_ms(100);
		}
		if(data=='f') // forward
		{
			data='\0';
		}
		if(data=='r') // right	
		{
			data='\0';
			turn_right();
		}
		if(data=='l') // left
		{
			data='\0';
			turn_left();
		} 
		if(data == 'h') // halt
		{
			data='\0';
			stop();
			_delay_ms(100);
			continue;
		
		}
		if(data == 'o') // origin
		{
			data='w';
			stop();
			_delay_ms(100);
			continue;
		}
		if(data == 'c') //collect item data -> i when the bot is trying to pick up an rfid
		{
			data='w';
			arm_down();
			_delay_ms(2700);
			stop_arm();
			_delay_ms(2000);
	       	grab();
			arm_up();
		    _delay_ms(3100);
		    stop_arm();
		    _delay_ms(2000);
			lcd_cursor(2,1);
			lcd_string("Collecting");
			_delay_ms(3500);
			readrfidtag();	
			clearrfid();     
			continue;   
			
		}
		if(data == 'd') //drop_item
		{
			data='w';
			go_down();
			release();
	        go_up();
			lcd_cursor(2,1);
			lcd_string("Dropping");
			_delay_ms(3500);
			senddroppedsig();
			continue;
		}
		
		while(1) 
		{
			if(move_bot() == 1)
			{
				continue;
			}
			else 
			{
				break;
			}
		}
	}
}

 port& operator= (port&& rhs) {
     if (this != &rhs) {
         release(); m_blob = rhs.m_blob; rhs.m_blob = nullptr;
     }
     return *this;
 }

//.........这里部分代码省略.........
	    fflush(NULL);

	    /* Create a pipe to serve as an error indicator. */
	    if (pipe(pfd) < 0) {
		report("pipe");
		goto bad;
	    }
	    (void) fcntl(pfd[1], F_SETFD,
		    fcntl(pfd[1], F_GETFD) | FD_CLOEXEC);

	    /* Fork and exec. */
	    switch (fork()) {
	    case -1:
		report("fork");
		close(pfd[0]);
		close(pfd[1]);
		goto bad;
	    case 0:
		close(tcp_fd);
		close(pfd[0]);
#if PARANOID
		/* Check if access to this service allowed. */
		if (ioctl(client_fd, NWIOGTCPCONF, &tcpconf) == 0
		    && tcpconf.nwtc_remaddr != tcpconf.nwtc_locaddr
		    && !servxcheck(tcpconf.nwtc_remaddr, argv[1], NULL)
		) {
		    exit(1);
		}
#endif
		sigprocmask(SIG_SETMASK, &oldmask, NULL);
		dup2(client_fd, 0);
		dup2(client_fd, 1);
		close(client_fd);
		execvp(progv[0], progv);
		report(progv[0]);
		write(pfd[1], &errno, sizeof(errno));
		exit(1);
	    default:
		nchildren++;
		release(&client_fd);
		close(pfd[1]);
		r= read(pfd[0], &errno, sizeof(errno));
		close(pfd[0]);
		if (r != 0) goto bad;
		break;
	    }
	}

	while (nchildren >= max_children) {
	    /* Too many clients, wait for one to die off. */
	    sigsuspend(&chldunmask);
	}

	/* Wait for a new connection. */
	sigprocmask(SIG_UNBLOCK, &chldmask, NULL);

	tcplistenopt.nwtcl_flags= 0;
	while (ioctl(tcp_fd, NWIOTCPLISTEN, &tcplistenopt) < 0) {
	    if (errno != EINTR) {
		if (errno != EAGAIN || debug) {
		    report("Unable to listen");
		}
		goto bad;
	    }
	}
	sigprocmask(SIG_BLOCK, &chldmask, NULL);

	/* We got a connection. */
	client_fd= tcp_fd;
	tcp_fd= -1;

	if (debug && ioctl(client_fd, NWIOGTCPCONF, &tcpconf) == 0) {
	    fprintf(stderr, "%s %s: Connection from %s:%u\n",
		arg0, service,
		inet_ntoa(tcpconf.nwtc_remaddr),
		ntohs(tcpconf.nwtc_remport));
	}
	/* All is well, no need to stall. */
	stall= 0;
	continue;

    bad:
	/* All is not well, release resources. */
	release(&tcp_fd);
	release(&client_fd);

	/* Wait a bit if this happens more than once. */
	if (stall != 0) {
	    if (debug) {
		fprintf(stderr, "%s %s: stalling %u second%s\n",
		    arg0, service,
		    stall, stall == 1 ? "" : "s");
	    }
	    sleep(stall);
	    stall <<= 1;
	} else {
	    stall= 1;
	}
    }
}

_XEngineLogo::~_XEngineLogo()
{
    release();
}

SSLContext::~SSLContext()
{
    release();
}

void
ScopedCancelHandle::cancel()
{
  release().cancel();
}

WBaseStream::~WBaseStream() {
    close();
    release();
}