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

static char *execute(char *command, int wait) /* {{{1 */{	STARTUPINFO si;	PROCESS_INFORMATION pi;	ZeroMemory(&si, sizeof(si));	ZeroMemory(&pi, sizeof(pi));	si.cb = sizeof(si);	if (CreateProcess(0, command, 0, 0, 0, CREATE_NO_WINDOW, 0, 0, &si, &pi)) {		if (wait) {			WaitForSingleObject(pi.hProcess, INFINITE);			/* long exit_code; */			/* TODO: GetExitCodeProcess( pi.hProcess, &exit_code); */			CloseHandle(pi.hProcess);			CloseHandle(pi.hThread);		}		return Success(NULL);	} else {		return Failure(GetError());	}}

BOOL CGuiRecordSet::GetCollect(int nIndex,CString& strValue){	_variant_t vt;	_variant_t vtn;	vtn.vt = VT_I2;	try	{			vtn.iVal = nIndex;		vt = m_rs->Fields->GetItem(vtn)->Value;		if (vt.vt==VT_BSTR)		{			strValue=vt.bstrVal;			return TRUE;		}else return FALSE;	}catch(_com_error &e)	{		GetError(e);		return FALSE;	}}

float CCoreAudioUnit::GetLatency(){  if (!m_audioUnit)    return 0.0f;  Float64 latency;  UInt32 size = sizeof(latency);  OSStatus ret = AudioUnitGetProperty(m_audioUnit,    kAudioUnitProperty_Latency, kAudioUnitScope_Global, 0, &latency, &size);  if (ret)  {    CLog::Log(LOGERROR, "CCoreAudioUnit::GetLatency: "      "Unable to set AudioUnit latency. Error = %s", GetError(ret).c_str());    return 0.0f;  }  return latency;}

/** * Updates the status (active/inactive) of an iam user's access key, based on * command line input */int main(int argc, char** argv){    if(argc != 4) {        PrintUsage();        return 1;    }    Aws::String user_name(argv[1]);    Aws::String accessKeyId(argv[2]);    auto status =        Aws::IAM::Model::StatusTypeMapper::GetStatusTypeForName(argv[3]);    if (status == Aws::IAM::Model::StatusType::NOT_SET) {        PrintUsage();        return 1;    }    Aws::SDKOptions options;    Aws::InitAPI(options);    {        Aws::IAM::IAMClient iam;        Aws::IAM::Model::UpdateAccessKeyRequest request;        request.SetUserName(user_name);        request.SetAccessKeyId(accessKeyId);        request.SetStatus(status);        auto outcome = iam.UpdateAccessKey(request);        if (outcome.IsSuccess()) {            std::cout << "Successfully updated status of access key " <<                accessKeyId << " for user " << user_name << std::endl;        } else {            std::cout << "Error updated status of access key " << accessKeyId <<                " for user " << user_name << ": " <<                outcome.GetError().GetMessage() << std::endl;        }    }    Aws::ShutdownAPI(options);    return 0;}

bool CParseBase::BasicParseLoop(CCodeElementList *pCodeList){	CObjectClass *pOC;		while((pOC = GetNextObjectClass(m_iCurLine)) != 0)	{		if (!pOC->Parse(*this, *pCodeList))			return false;	}	if (m_iCurPos >= (int) m_msText[m_iCurLine].csText.Len())	{		SetError(CPB_EOL);	// End of Line		return false;	}		if (GetError() != CPB_NOERROR)		return false;	return true;}

Float64 CCoreAudioDevice::GetNominalSampleRate(){  if (!m_DeviceId)    return 0.0f;  AudioObjectPropertyAddress  propertyAddress;  propertyAddress.mScope    = kAudioDevicePropertyScopeOutput;  propertyAddress.mElement  = 0;  propertyAddress.mSelector = kAudioDevicePropertyNominalSampleRate;  Float64 sampleRate = 0.0f;  UInt32  propertySize = sizeof(Float64);  OSStatus ret = AudioObjectGetPropertyData(m_DeviceId, &propertyAddress, 0, NULL, &propertySize, &sampleRate);  if (ret != noErr)  {    CLog::Log(LOGERROR, "CCoreAudioDevice::GetNominalSampleRate: "      "Unable to retrieve current device sample rate. Error = %s", GetError(ret).c_str());    return 0.0f;  }  return sampleRate;}

BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,int& nValue){	_variant_t vt;	try	{		vt = m_rs->Fields->GetItem(lpField)->Value;		if (vt.vt==VT_I2)		{			nValue=vt.intVal;			return TRUE;		}else if (vt.vt==VT_BOOL)		{			nValue=vt.boolVal;			return TRUE;		}else return FALSE;	}catch(_com_error &e)	{		GetError(e);		return FALSE;	}}

bool CAUOutputDevice::SetCurrentDevice(AudioDeviceID deviceId){  if (!m_audioUnit)    return false;  OSStatus ret = AudioUnitSetProperty(m_audioUnit, kAudioOutputUnitProperty_CurrentDevice,    kAudioUnitScope_Global, kOutputBus, &deviceId, sizeof(AudioDeviceID));  if (ret)  {    CLog::Log(LOGERROR, "CCoreAudioUnit::SetCurrentDevice: "      "Unable to set current device. Error = %s", GetError(ret).c_str());    return false;  }  m_DeviceId = deviceId;  CLog::Log(LOGDEBUG, "CCoreAudioUnit::SetCurrentDevice: "    "Current device 0x%08x", (uint)m_DeviceId);  return true;}

bool CAUOutputDevice::SetChannelMap(CoreAudioChannelList* pChannelMap){  // The number of array elements must match the  // number of output channels provided by the device  if (!m_audioUnit || !pChannelMap)    return false;  UInt32 channels = pChannelMap->size();  UInt32 size = sizeof(SInt32) * channels;  SInt32* pMap = new SInt32[channels];  for (UInt32 i = 0; i < channels; i++)    pMap[i] = (*pChannelMap)[i];  OSStatus ret = AudioUnitSetProperty(m_audioUnit,    kAudioOutputUnitProperty_ChannelMap, kAudioUnitScope_Input, 0, pMap, size);  if (ret)    CLog::Log(LOGERROR, "CCoreAudioUnit::GetBufferFrameSize: "      "Unable to get current device's buffer size. Error = %s", GetError(ret).c_str());  delete[] pMap;  return (!ret);}

UbuntuUnityHack::UbuntuUnityHack(QObject* parent)  : QObject(parent){  // Check if we're on Ubuntu first.  QFile lsb_release("/etc/lsb-release");  if (lsb_release.open(QIODevice::ReadOnly)) {    QByteArray data = lsb_release.readAll();    if (!data.contains("DISTRIB_ID=Ubuntu")) {      // It's not Ubuntu - don't do anything.      return;    }  }  // Get the systray whitelist from gsettings.  If this fails we're probably  // not running on a system with unity  QProcess* get = new QProcess(this);  connect(get, SIGNAL(finished(int)), SLOT(GetFinished(int)));  connect(get, SIGNAL(error(QProcess::ProcessError)), SLOT(GetError()));  get->start(kGSettingsFileName, QStringList()             << "get" << kUnityPanel << kUnitySystrayWhitelist);}

bool CCoreAudioDevice::AddIOProc(){  // Allow only one IOProc at a time  if (!m_DeviceId || m_IoProc)    return false;  OSStatus ret = AudioDeviceCreateIOProcID(m_DeviceId, DirectRenderCallback, this, &m_IoProc);  if (ret)  {    CLog::Log(LOGERROR, "CCoreAudioDevice::AddIOProc: "      "Unable to add IOProc. Error = %s", GetError(ret).c_str());    m_IoProc = NULL;    return false;  }  Start();  CLog::Log(LOGDEBUG, "CCoreAudioDevice::AddIOProc: "    "IOProc %p set for device 0x%04x", m_IoProc, (uint)m_DeviceId);  return true;}

HWNDCreateMainWindow(LPCTSTR lpCaption,                 int nCmdShow){    PMAIN_WND_INFO Info;    HWND hMainWnd = NULL;    Info = (MAIN_WND_INFO*) HeapAlloc(ProcessHeap,                     HEAP_ZERO_MEMORY,                     sizeof(MAIN_WND_INFO));    if (Info != NULL)    {        Info->nCmdShow = nCmdShow;        hMainWnd = CreateWindowEx(WS_EX_WINDOWEDGE,                                  szMainWndClass,                                  lpCaption,                                  WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,                                  CW_USEDEFAULT,                                  CW_USEDEFAULT,                                  680,                                  450,                                  NULL,                                  NULL,                                  hInstance,                                  Info);        if (hMainWnd == NULL)        {            //int ret;            //ret = GetLastError();            GetError();            HeapFree(ProcessHeap,                     0,                     Info);        }    }    return hMainWnd;}

HWNDCreateMainWindow(LPCTSTR lpCaption,                 int nCmdShow){    PMAIN_WND_INFO Info;    HWND hMainWnd = NULL;    Info = (PMAIN_WND_INFO)HeapAlloc(ProcessHeap,                                     HEAP_ZERO_MEMORY,                                     sizeof(MAIN_WND_INFO));    if (Info != NULL)    {        Info->nCmdShow = nCmdShow;        Info->Display = DevicesByType;        Info->bShowHidden = TRUE;        hMainWnd = CreateWindowEx(WS_EX_WINDOWEDGE,                                  szMainWndClass,                                  lpCaption,                                  WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,                                  CW_USEDEFAULT,                                  CW_USEDEFAULT,                                  600,                                  450,                                  NULL,                                  NULL,                                  hInstance,                                  Info);        if (hMainWnd == NULL)        {            GetError();            HeapFree(ProcessHeap,                     0,                     Info);        }    }    return hMainWnd;}

/** * Creates a cloud watch logs subscription filter, based on command line input */int main(int argc, char** argv){    if (argc != 5)    {        std::cout << "Usage: " << std::endl << "  put_subscription_filter "            << "<filter_name> <filter_pattern> <log_group_name> " <<            "<lambda_function_arn>" << std::endl;        return 1;    }    Aws::SDKOptions options;    Aws::InitAPI(options);    {        Aws::String filter_name(argv[1]);        Aws::String filter_pattern(argv[2]);        Aws::String log_group(argv[3]);        Aws::String dest_arn(argv[4]);        Aws::CloudWatchLogs::CloudWatchLogsClient cwl;        Aws::CloudWatchLogs::Model::PutSubscriptionFilterRequest request;        request.SetFilterName(filter_name);        request.SetFilterPattern(filter_pattern);        request.SetLogGroupName(log_group);        request.SetDestinationArn(dest_arn);        auto outcome = cwl.PutSubscriptionFilter(request);        if (!outcome.IsSuccess())        {            std::cout << "Failed to create cloudwatch logs subscription filter "                << filter_name << ": " << outcome.GetError().GetMessage() <<                std::endl;        }        else        {            std::cout << "Successfully created cloudwatch logs subscription " <<                "filter " << filter_name << std::endl;        }    }    Aws::ShutdownAPI(options);    return 0;}

bool CCoreAudioDevice::RemoveIOProc(){  if (!m_DeviceId || !m_IoProc)    return false;  Stop();  OSStatus ret = AudioDeviceDestroyIOProcID(m_DeviceId, m_IoProc);  if (ret)    CLog::Log(LOGERROR, "CCoreAudioDevice::RemoveIOProc: "      "Unable to remove IOProc. Error = %s", GetError(ret).c_str());  else    CLog::Log(LOGDEBUG, "CCoreAudioDevice::RemoveIOProc: "      "IOProc %p removed for device 0x%04x", m_IoProc, (uint)m_DeviceId);  m_IoProc = NULL; // Clear the reference no matter what  m_pSource = NULL;  Sleep(100);  return true;}

void ConnectThread::ThreadFunc(){	m_socket = m_address.m_socketFactory->CreateSocket();	m_socket->Bind(m_address.m_localIP, m_address.m_localPort);	if(m_socket->Connect(m_address.m_ip, m_address.m_port))	{		Connector* connector = m_address.m_connectorFactory->CreateConnector(m_socket);		connector->SetId(m_address.m_id);		connector->SetRemoteAddr(m_address.m_ip, m_address.m_port);		m_socket = 0;		ConnectorMessage msg(connector);		onSignal(msg);	}	else	{		ConnectErrorMessage errMsg(m_address.m_moduleName, "", GetError());		onSignal(errMsg);		delete m_socket;		m_socket = 0;	}}

int main(){    int n, TC;    printf("Input dimension (n): ");    scanf("%d", &n);    if (n <= 0) return -1;    printf("Input number of the threads: ");    scanf("%d", &TC);    if (n <= 0) return -2;    double * a = new double[n*n];    double * b = new double[n];    double * x = new double[n];    int * index = new int[n];    double * ac = new double[n*n];    double * bc = new double[n*n];    FillMatrix(a, b, n);    for (int i = 0; i < n*n; i++) ac[i] = a[i]; // copy of A    for (int i = 0; i < n; i++) bc[i] = b[i]; // copy of B    PrintMatrix(a, b, n);    timeval tv1;    gettimeofday(&tv1, 0);    if (!SolveSystem(n, a, b, x, index, TC))    {	printf("Bad matrix!/n");	return -3;    }    timeval tv2;    gettimeofday(&tv2,0);    double Time = double(tv2.tv_sec)*1000000.0+double(tv2.tv_usec)-double(tv1.tv_sec)*1000000.0+double(tv1.tv_usec);	    printf("Result:/n"); PrintSolution(x, n);    printf("/n/nThreads: %d,/nError: %1.17lf,/nTime=%1.4lf sec./n", TC, GetError(ac, bc, x, n), Time/1000000.0);    delete a; delete b;    delete x; delete index;        delete ac;    return 0;}

    // ========================================================================    // Function:    GetIPAddress    // Purpose:     To get the IP address of the string as an ipaddress    //              structure. Throws an exception if the address cannot be    //              converted.    // ========================================================================    ipaddress GetIPAddress( const std::string p_address )    {                if( IsIPAddress( p_address ) )        {            // if the address is just a regular IP address, there's no need            // to do a DNS lookup, so just convert the string directly into            // its binary format.            ipaddress addr = inet_addr( p_address.c_str() );                        // if the address is invalid, throw a HOST_NOT_FOUND exception.            if( addr == INADDR_NONE )            {                throw Exception( EDNSNotFound );            }            // by this point, the address is valid, so return it.            return addr;        }        else        {            // the address isn't an IP address, so we need to look it up using            // DNS.             struct hostent* host = gethostbyname( p_address.c_str() );            // if there was an error, throw an exception.            if( host == 0 )            {                // get the error from h_errno.                throw Exception( GetError( false ) );            }            // now perform some really wierd casting tricks to get the value.            // h_addr is a char*, so cast it into an ipaddress*, and             // dereference it to get the value.            return *((ipaddress*)host->h_addr);        }    }

/** * Creates a long-polled sqs queue based on command line input */int main(int argc, char** argv){    if (argc != 3)    {        std::cout << "Usage: long_polling_on_create_queue <queue_name> " <<            "<poll_time_in_seconds>" << std::endl;        return 1;    }    Aws::SDKOptions options;    Aws::InitAPI(options);    {        Aws::String queue_name = argv[1];        Aws::String poll_time = argv[2];        Aws::SQS::SQSClient sqs;        Aws::SQS::Model::CreateQueueRequest request;        request.SetQueueName(queue_name);        request.AddAttributes(            Aws::SQS::Model::QueueAttributeName::ReceiveMessageWaitTimeSeconds,            poll_time);        auto outcome = sqs.CreateQueue(request);        if (outcome.IsSuccess())        {            std::cout << "Successfully created queue " << queue_name <<                std::endl;        }        else        {            std::cout << "Error creating queue " << queue_name << ": " <<                outcome.GetError().GetMessage() << std::endl;        }    }    Aws::ShutdownAPI(options);    return 0;}

/** * Deletes an access key from an IAM user, based on command line input */int main(int argc, char** argv){    if (argc != 3)    {        std::cout << "Usage: delete_access_key <user_name> <access_key_id>"            << std::endl;        return 1;    }    Aws::SDKOptions options;    Aws::InitAPI(options);    {        Aws::String user_name(argv[1]);        Aws::String key_id(argv[2]);        Aws::IAM::IAMClient iam;        Aws::IAM::Model::DeleteAccessKeyRequest request;        request.SetUserName(user_name);        request.SetAccessKeyId(key_id);        auto outcome = iam.DeleteAccessKey(request);        if (!outcome.IsSuccess())        {            std::cout << "Error deleting access key " << key_id << " from user "                << user_name << ": " << outcome.GetError().GetMessage() <<                std::endl;        }        else        {            std::cout << "Successfully deleted access key " << key_id                << " for IAM user " << user_name << std::endl;        }    }    Aws::ShutdownAPI(options);    return 0;}

ModelicaCompiler::ModelicaCompiler(string model,string file_name,string model_path,bool load_file, bool load_package):_model(model),_file_name(file_name),_model_path(model_path),_load_package(load_package),_omcPtr(0){  std::cout << "Modelica compiler file "<< std::endl;  char* omhome= getenv ("OPENMODELICAHOME");//should get value for OM home  std::cout << "omhome " << omhome << std::endl;  if(omhome==NULL)    std::cout << "OPENMODELICAHOME variable doesn't set" << std::endl;  //string path = getTempPath();  int status =0;  std::cout << "Intialize OMC, use gcc" << std::endl;  status = InitOMC(&_omcPtr,"gcc",omhome);  if(status > 0)  {    std::cout << "..ok" << std::endl;    loadFile(load_file);  }  else  {    std::cout << "..failed" << std::endl;    char* errorMsg = 0;    status = GetError(_omcPtr, &errorMsg);    string errorMsgStr(errorMsg);    throw std::runtime_error("error to intialize OMC: " + errorMsgStr);  }}

BOOL CFlashManager::Flash_Start(IDispatch* pDisp){	CFuncLog log(g_pLog, "CFlashManager::Flash_Start()");	CComQIPtr<ShockwaveFlashObjects::IShockwaveFlash> spSWF(pDisp);	if (!spSWF)	{		log.LogString(LOG_ERROR, " FAILURE: CComQIPtr<ShockwaveFlashObjects::IShockwaveFlash> spSWF == NULL)");			return FALSE;	}	// If using the wsShell.swf loader then to play the 	// flash we must actually call Rewind(). This fixes the 	// problem where flash types with the wsShell loader were 	// failing to play. For all other flash types we call Play().	HRESULT hr = S_OK;	if (IsWsShellUsed(pDisp))		hr = spSWF->Rewind();	else		hr = spSWF->Play();	if (FAILED(hr))	{		CString szMsg;		szMsg.Format("Play/Rewind FAILED(%X)", hr); 		GetError(szMsg);		log.LogString(LOG_ERROR, szMsg.GetBuffer());		return FALSE;	}	if (g_pLog)	{		CString szMsg;		szMsg.Format("SUCCESS"); 		log.LogString(LOG_INFO, szMsg.GetBuffer());	}	return TRUE;}

void ReloadCustomImage(Bitmap *bitmap, char *basename){  char *filename = getCustomImageFilename(basename);  Bitmap *new_bitmap;  if (filename == NULL)		/* (should never happen) */  {    Error(ERR_WARN, "ReloadCustomImage(): cannot find file '%s'", basename);    return;  }  if (strEqual(filename, bitmap->source_filename))  {    /* The old and new image are the same (have the same filename and path).       This usually means that this image does not exist in this graphic set       and a fallback to the existing image is done. */    return;  }  if ((new_bitmap = LoadImage(filename)) == NULL)  {    Error(ERR_WARN, "LoadImage() failed: %s", GetError());    return;  }  if (bitmap->width != new_bitmap->width ||      bitmap->height != new_bitmap->height)  {    Error(ERR_WARN, "ReloadCustomImage: new image '%s' has wrong dimensions",	  filename);    FreeBitmap(new_bitmap);    return;  }  TransferBitmapPointers(new_bitmap, bitmap);  free(new_bitmap);}