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

void Session::FinalRelease(){    LogFlowThisFunc(("/n"));    uninit();    BaseFinalRelease();}

void CvGameRecord::reset(){	uninit();	m_eEra = NO_ERA;	m_szMapName.clear();}

WasapiEngine::~WasapiEngine() {	uninit();	QSettings settings;	settings.beginGroup("wasapiengine");	settings.setValue("deviceIndex", deviceIndex);	settings.endGroup();}

static int init(struct ao *ao){    MP_DBG(ao, "Init wasapi/n");    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);    struct wasapi_state *state = ao->priv;    state->log = ao->log;    state->deviceID = find_deviceID(ao);    if (!state->deviceID) {        uninit(ao);        return -1;    }    wasapi_change_init(ao, false);    state->hInitDone = CreateEventW(NULL, FALSE, FALSE, NULL);    state->hWake     = CreateEventW(NULL, FALSE, FALSE, NULL);    if (!state->hInitDone || !state->hWake) {        MP_ERR(ao, "Error creating events/n");        uninit(ao);        return -1;    }    state->init_ret = E_FAIL;    state->hAudioThread = CreateThread(NULL, 0, &AudioThread, ao, 0, NULL);    if (!state->hAudioThread) {        MP_ERR(ao, "Failed to create audio thread/n");        uninit(ao);        return -1;    }    WaitForSingleObject(state->hInitDone, INFINITE); // wait on init complete    SAFE_RELEASE(state->hInitDone,CloseHandle(state->hInitDone));    if (state->init_ret != S_OK) {        if (!ao->probing)            MP_ERR(ao, "Received failure from audio thread/n");        uninit(ao);        return -1;    }    wasapi_receive_proxies(state);    MP_DBG(ao, "Init wasapi done/n");    return 0;}

HRESULT MachineToken::abandon(AutoCaller &aAutoCaller){    /* have to release the AutoCaller before calling uninit(), self-deadlock */    aAutoCaller.release();    /* uninit does everything we need */    uninit(true);    return S_OK;}

int main() {  init();  while (step())    ;  for (int i = 0; i < 5; i++) {    printf("%d", strip[i + 1000 * 500]);  }  uninit();}

void LocalHttpServer::stop(void){	if (m_spP2pInterface.get())	{		m_spP2pInterface->uninit_p2p_system();	}	uninit();}

//// This function is called to init the video driver for specific mode//static int config(uint32_t width, uint32_t height, uint32_t d_width,                       uint32_t d_height, uint32_t flags, char *title,                       uint32_t format) {  int32_t req_w = width;// (d_width > 0 ? d_width : width);  int32_t req_h = height;// (d_height > 0 ? d_height : height);  uint16_t vid_mode = 0;  int32_t req_bpp;    uint32_t accflags;  if( mp_msg_test(MSGT_VO,MSGL_V) )    mp_msg(MSGT_VO,MSGL_V, "vo_svga: config(%i, %i, %i, %i, %08x, %s, %08x)/n", width, height,           d_width, d_height, flags, title, format);//Only RGB modes supported  if (!IMGFMT_IS_RGB(format) && !IMGFMT_IS_BGR(format)) {assert(0);return -1;}   req_bpp = IMGFMT_BGR_DEPTH(format);      if( vo_dbpp!=0 && vo_dbpp!=req_bpp) {assert(0);return-1;}      if(!force_vm) {    if ( mp_msg_test(MSGT_VO,MSGL_V) ) {      mp_msg(MSGT_VO,MSGL_V, "vo_svga: Looking for the best resolution.../n");      mp_msg(MSGT_VO,MSGL_V, "vo_svga: req_w: %d, req_h: %d, bpp: %d/n",req_w,req_h,req_bpp);    }    vid_mode=find_best_svga_mode(req_w,req_h,req_bpp);    if(vid_mode==0)       return 1;    modeinfo=vga_getmodeinfo(vid_mode);  }else{//force_vm    vid_mode=force_vm;    if(vga_hasmode(vid_mode) == 0){      mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SVGA_ForcedVidmodeNotAvailable,             vid_mode,vga_getmodename(vid_mode));      return 1; //error;    }    modeinfo=vga_getmodeinfo(vid_mode);    if( (modeinfo->width < req_w) || (modeinfo->height < req_h) ){      mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SVGA_ForcedVidmodeTooSmall,             vid_mode,vga_getmodename(vid_mode));      return 1;    }  }  mode_bpp=bpp_from_vminfo(modeinfo);       mp_msg(MSGT_VO,MSGL_INFO, MSGTR_LIBVO_SVGA_Vidmode,         vid_mode,modeinfo->width,modeinfo->height,mode_bpp);    if (vga_setmode(vid_mode) == -1) {    mp_msg(MSGT_VO,MSGL_ERR, MSGTR_LIBVO_SVGA_VgasetmodeFailed,vid_mode);    uninit();    return 1; // error  }  /* set 332 palette for 8 bpp */  if(mode_bpp==8){    int i;    for(i=0; i<256; i++)      vga_setpalette(i, ((i>>5)&7)*9, ((i>>2)&7)*9, (i&3)*21);  }

ErrVal ReadBitstreamFile::destroy(){  AOT_DBG( m_cFile.is_open() );  RNOK( uninit() );    delete this;  return Err::m_nOK;}

void CFtpSocket::closeSocket(){	if( INVALID_SOCKET != m_Sock )	{		closesocket( m_Sock );		m_Sock = INVALID_SOCKET;	}	uninit();}

static int _restart(){	// report to the SCM that we're about to start	utils_trace("Re-starting PMC Serial Port Access Coordinator Version 1.0.../n");	uninit();	init();	utils_trace("PMC Serial Port Access Coordinator Version 1.0 re-started.../n");	return 1;}

// FUNCTION: reset()// Initializes data members that are serialized.void CvRandom::reset(unsigned long long ullSeed){	//--------------------------------	// Uninit class	uninit();	m_ullRandomSeed = ullSeed;	m_ulResetCount++;}

CAppManConnectController::~CAppManConnectController(){    LOG4CPLUS_TRACE_METHOD(msLogger, __PRETTY_FUNCTION__);    uninit();    mpConnection->disconnect();    delete mpConnection;    delete mpClient;    delete mpCore;}

void VBoxVetoEvent::FinalRelease(){    if (m)    {        uninit();        delete m;        m = NULL;    }    BaseFinalRelease();}

	Kinect::~Kinect() {		uninit();		DeleteCriticalSection(&_csVideo);		DeleteCriticalSection(&_csDepth);		DeleteCriticalSection(&_csSkeleton);		CloseHandle(_nextVideoFrameEvent);		CloseHandle(_nextDepthFrameEvent);		CloseHandle(_nextSkeletonEvent);		CloseHandle(_nuiProcessStop);	}

CAppManConnectController::~CAppManConnectController(){    LOG4CPLUS_TRACE(msLogger,"~CAppManConnectController()");    uninit();    mpConnection->disconnect();    delete mpConnection;    delete mpClient;    delete mpCore;}

void VBoxEvent::FinalRelease(){    if (m)    {        uninit();        delete m;        m = 0;        BaseFinalRelease();    }}

static void __exit mtk_fm_remove(void){    int ret = 0;    ret = uninit(&op);    if(ret){        FM_LOG_ALT(D_INIT,"%s, FM uninit failed/n", __func__);    }    FM_LOG_NTC(D_INIT,"%s, FM remove ok/n", __func__);    return;}

void ProgressProxy::FinalRelease(){    uninit();    mfMultiOperation = false;    muOtherProgressStartWeight    = 0;    muOtherProgressWeight         = 0;    muOtherProgressStartOperation = 0;    BaseFinalRelease();}

bool CFtpSocket::connectTo( const char* serverAddr, int serverPort ){	assert( m_Sock == INVALID_SOCKET );	m_Sock = WSASocket( AF_INET, SOCK_STREAM, IPPROTO_TCP,		NULL, 0, WSA_FLAG_OVERLAPPED );	if( INVALID_SOCKET == m_Sock )	{		//CLogger::getInst()<<_T("建立侦听端口失败！错误号：")		//	<< WSAGetLastError()<<_T("/n");		uninit();		return false;	}	memset( &m_InternetAddr, 0, sizeof( sockaddr_in ) );	m_InternetAddr.sin_family			= AF_INET;	m_InternetAddr.sin_addr.s_addr	= inet_addr( serverAddr );	m_InternetAddr.sin_port			= htons( serverPort );	//CLogger::getInst()<<_T("连接服务器.../n");	if( m_InternetAddr.sin_addr.s_addr == INADDR_NONE )	{		//CLogger::getInst()<<_T("启用DNS解析.../n");		LPHOSTENT lpHostent = gethostbyname( serverAddr );		if( NULL == lpHostent )		{			//CLogger::getInst()<<_T("无法解析服务器地址！")<< "错误号:" << WSAGetLastError() << "/n";			return false;		}		else		{			m_InternetAddr.sin_addr.s_addr = ((in_addr*)lpHostent->h_addr)->s_addr;			//char* IP = inet_ntoa(*((in_addr*)lpHostent->h_addr));			//CLogger::getInst()<<_T("解析结果：")<<IP<<std::endl;		}	}	int err;	err = connect( m_Sock, (const sockaddr*)&m_InternetAddr,		sizeof(sockaddr_in) );	if( SOCKET_ERROR == err )	{		//CLogger::getInst()<<_T("无法连接到服务器！")<< "错误号:" << WSAGetLastError() << "/n";		//int nn = WSAGetLastError();		return false;	}	//CLogger::getInst()<<_T("连接服务器：[")<<serverAddr<<_T(":")/	//	<<serverPort<<_T("]成功！/n");	return true;}

/** init() Initalises the parameters of a class instance. This must be called before use  @param n_ The size of the data windows to be processed  @param k_ The number of outputs wanted (autocorr size = n_ + k_). Set k_ = 0, to get default n_/2  @param rate_ The sampling rate of the incoming signal to process  @param threshold_ The ratio of highest peak to the first peak allowed to be chosen*/void MyTransforms::init(int n_, int k_, double rate_, /*float threshold_, */bool equalLoudness_, int numHarmonics_){  const int myFFTMode = FFTW_ESTIMATE;  //const int myFFTMode = FFTW_MEASURE;  //const int myFFTMode = FFTW_PATIENT;  uninit();  if(k_ == 0) k_ = (n_ + 1) / 2;    n = n_;  k = k_;  size = n + k;  rate = rate_;  //_threshold = threshold_;  equalLoudness = equalLoudness_;  numHarmonics = numHarmonics_;  dataTemp = (float*)fftwf_malloc(sizeof(float) * n);  dataTime = (float*)fftwf_malloc(sizeof(float) * n);  dataFFT  =  (float*)fftwf_malloc(sizeof(float) * n);  autocorrTime = (float*)fftwf_malloc(sizeof(float) * size);  autocorrFFT  = (float*)fftwf_malloc(sizeof(float) * size);  //storeFFT  = (float*)fftwf_malloc(sizeof(float) * size);  //equalLoudnessTable = (float*)fftwf_malloc(sizeof(float) * n);  hanningCoeff  = (float*)fftwf_malloc(sizeof(float) * n);  planAutocorrTime2FFT = fftwf_plan_r2r_1d(size, autocorrTime, autocorrFFT, FFTW_R2HC, myFFTMode);  planAutocorrFFT2Time = fftwf_plan_r2r_1d(size, autocorrFFT, autocorrTime, FFTW_HC2R, myFFTMode);    planDataTime2FFT = fftwf_plan_r2r_1d(n, dataTime, dataFFT, FFTW_R2HC, myFFTMode);  planDataFFT2Time = fftwf_plan_r2r_1d(n, dataFFT, dataTime, FFTW_HC2R, myFFTMode); //???  harmonicsAmpLeft = (float*)fftwf_malloc(numHarmonics * sizeof(float));  harmonicsPhaseLeft = (float*)fftwf_malloc(numHarmonics * sizeof(float));  harmonicsAmpCenter = (float*)fftwf_malloc(numHarmonics * sizeof(float));  harmonicsPhaseCenter = (float*)fftwf_malloc(numHarmonics * sizeof(float));  harmonicsAmpRight = (float*)fftwf_malloc(numHarmonics * sizeof(float));  harmonicsPhaseRight = (float*)fftwf_malloc(numHarmonics * sizeof(float));  //storeFFTAmp1 = (float*)malloc(n/2 * sizeof(float));  //storeFFTAmp2 = (float*)malloc(n/2 * sizeof(float));    freqPerBin = rate / double(size);  //buildEqualLoudnessTable(50.0);  //init hanningCoeff. The hanning windowing function  hanningScalar = 0;  for(int j=0; j<n; j++) {    hanningCoeff[j] = (1.0 - cos(double(j+1) / double(n+1) * twoPI)) / 2.0;    hanningScalar += hanningCoeff[j];  }  hanningScalar /= 2; //to normalise the FFT coefficients we divide by the sum of the hanning window / 2  fastSmooth = new fast_smooth(n/8);  //printf("fast_smooth size = %d/n", n/8);  beenInit = true;}

static int init(struct ao *ao){    MP_DBG(ao, "Init wasapi/n");    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);    struct wasapi_state *state = ao->priv;    state->log = ao->log;    if(!wasapi_fill_VistaBlob(state))        MP_WARN(ao, "Error loading thread priority functions/n");    state->hInitDone = CreateEventW(NULL, FALSE, FALSE, NULL);    state->hWake     = CreateEventW(NULL, FALSE, FALSE, NULL);    if (!state->hInitDone || !state->hWake) {        MP_ERR(ao, "Error creating events/n");        uninit(ao);        return -1;    }    state->init_ret = E_FAIL;    state->hAudioThread = CreateThread(NULL, 0, &AudioThread, ao, 0, NULL);    if (!state->hAudioThread) {        MP_ERR(ao, "Failed to create audio thread/n");        uninit(ao);        return -1;    }    WaitForSingleObject(state->hInitDone, INFINITE); /* wait on init complete */    SAFE_RELEASE(state->hInitDone,CloseHandle(state->hInitDone));    if (state->init_ret != S_OK) {        if (!ao->probing)            MP_ERR(ao, "Received failure from audio thread/n");        uninit(ao);        return -1;    }    wasapi_setup_proxies(state);    MP_DBG(ao, "Init wasapi done/n");    return 0;}

Direct3DBlitter::~Direct3DBlitter() {	uninit();	if (d3d)		d3d->Release();	if (d3d9handle)		FreeLibrary(d3d9handle);	QSettings settings;	settings.beginGroup("direct3dblitter");	settings.setValue("adapterIndex", adapterIndex);	settings.endGroup();}

static void	parent_signal_handler(int sig){	switch(sig)	{	case SIGCHLD:		zabbix_log( LOG_LEVEL_WARNING, "One child process died. Exiting ...");		uninit();		exit( FAIL );		break;	default:		child_signal_handler(sig);	}}

	void Tcp::loop()	{		if(init())		{			while(_running)			{				//do something				_tcpnet->runRecvMsg();				System::Sleep(50);			}		}		uninit();	}

/**Forks things.@return 0 if successful and -1 otherwise.**/int init_fork(void) {	/*	Creates a process monitor to avoid accidental daemonization.	*/	const pid_t child_pid = fork();	if (child_pid == -1) {		probno = log_error(FORK_PROBLEM);		return -1;	}	else {		pid = getpid();		if (child_pid == 0) {//child			shm_attach();			/*			Synchronizes with the parent process.			*/			while (shared.pids[0] != pid);			return NO_PROBLEM;		}		else {//parent			*shared.ppid = pid;			shared.pids[0] = child_pid;			/*			Prevents defunct processes from appearing.			*/			signal(SIGCHLD, SIG_IGN);			while (*shared.state != HAD_ENOUGH) {				napms(NAP_RESOLUTION / frame_rate);			}			do {				bool done_quitting = TRUE;				for (int save = 0; save < cfg_saves; save++) {					if (shared.pids[save] != 0) {						done_quitting = FALSE;					}				}				if (done_quitting) break;				napms(NAP_RESOLUTION / frame_rate);			} while (TRUE);			uninit(TRUE);			exit(NO_PROBLEM);		}	}	return 0;}

STDMETHODIMP GuestDirectory::Close(void){#ifndef VBOX_WITH_GUEST_CONTROL    ReturnComNotImplemented();#else    LogFlowThisFuncEnter();    AutoCaller autoCaller(this);    if (FAILED(autoCaller.rc())) return autoCaller.rc();    AssertPtr(mData.mSession);    int rc = mData.mSession->directoryRemoveFromList(this);    AssertRC(rc);    HRESULT hr = S_OK;    int guestRc;    rc = mData.mProcessTool.Terminate(30 * 1000, &guestRc);    if (RT_FAILURE(rc))    {        switch (rc)        {           case VERR_GSTCTL_GUEST_ERROR:                hr = GuestProcess::setErrorExternal(this, guestRc);                break;            case VERR_NOT_SUPPORTED:                /* Silently skip old Guest Additions which do not support killing the                 * the guest directory handling process. */                break;            default:                hr = setError(VBOX_E_IPRT_ERROR,                              tr("Terminating open guest directory /"%s/" failed: %Rrc"),                              mData.mName.c_str(), rc);                break;        }    }    /*     * Release autocaller before calling uninit.     */    autoCaller.release();    uninit();    LogFlowThisFunc(("Returning rc=%Rrc/n", rc));    return hr;#endif /* VBOX_WITH_GUEST_CONTROL */}

// ignore parameters in this sample servicevoid CSpacService :: Run(DWORD, LPTSTR *) {	if (g_SingleInstanceObj.IsAnotherInstanceRunning()){		utils_error("Another PMCSpac Daemon instance is already running./n");		return;	}		// report to the SCM that we're about to start	utils_trace("Starting PMC Serial Port Access Coordinator Version 1.0.../n");	ReportStatus(SERVICE_START_PENDING);		m_hStop = ::CreateEvent(0, FALSE, FALSE, 0);	SECURITY_ATTRIBUTES sd;	ZeroMemory(&sd, sizeof(sd));	sd.nLength = sizeof(sd);	m_hRestart = ::CreateEvent(&sd, FALSE, FALSE, SPAC_RESET_EVENT);	HANDLE handles[2];	handles[0] = m_hStop;	handles[1] = m_hRestart;	// You might do some more initialization here.	// Parameter processing for instance ...	utils_trace("PMC Serial Port Access Coordinator Version 1.0 started.../n");	init();	// enter main-loop	// If the Stop() method sets the event, then we will break out of	// this loop.	// report SERVICE_RUNNING immediately before you enter the main-loop	// DON'T FORGET THIS!	ReportStatus(SERVICE_RUNNING);		bool bStop = false;	while(!bStop){		switch(MsgWaitForMultipleObjects(2,handles,false,INFINITE,QS_ALLEVENTS) ){		case WAIT_OBJECT_0:			bStop = true;			break;		case WAIT_OBJECT_0 + 1:			_restart();			break;		case WAIT_OBJECT_0 + 2:			MSG msg;			while(PeekMessage(&msg,NULL,0,0,PM_REMOVE)){				TranslateMessage(&msg);				DispatchMessage(&msg);				break;			}		}	}	if( m_hStop )	::CloseHandle(m_hStop);	uninit();	ReportStatus(SERVICE_STOPPED);}

/* * Entry point */int main(int argc, char** argv){    try    {        /* Initialize the GLUT library. */        glutInit(&argc, argv);        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);        glutInitWindowPosition(5, 5);        glutInitWindowSize(WIDTH, HEIGHT);        /* Create main window and set callbacks. */        glutCreateWindow(TITLE);        glutDisplayFunc(display);        glutReshapeFunc(reshape);        glutKeyboardFunc(myKeyboard);        glutMouseFunc(myMouse);  // uloha 6        if (spinFlag)        {            glutTimerFunc(33, FuncTimerCallback, 0);        }        createMenu();        // load the pointers to OpenGL functions (only needed in MS Windows)        glewInit();        if (!GLEW_VERSION_3_0) {            fprintf(stderr, "OpenGL 3.0 or higher not available/n");            return 1;        }        // Init context and profile         glutInitContextVersion(MAJOR_VERSION, MINOR_VERSION);        if ((MAJOR_VERSION >= 3) && (MINOR_VERSION >= 2))           glutInitContextProfile(PROFILE);   // core or compatibiliy, as defined in OpenGL 3.2        init();        glutMainLoop();    }    catch (const OpenGlException& ex)    {        std::cerr << "OpenGL reported an error: " << ex.GetGlError() << std::endl;    }    uninit();    system("PAUSE");    return 0;}