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

void OpenGLRenderer::beforeResize(bool wasOrIsFullscreen) {	#if ARX_PLATFORM == ARX_PLATFORM_LINUX || ARX_PLATFORM == ARX_PLATFORM_BSD	// No re-initialization needed	ARX_UNUSED(wasOrIsFullscreen);#else		if(!isInitialized()) {		return;	}		#if ARX_PLATFORM == ARX_PLATFORM_WIN32	if(!wasOrIsFullscreen) {		return;	}	#else	// By default, always reinit to avoid issues on untested platforms	ARX_UNUSED(wasOrIsFullscreen);	#endif		shutdown();	#endif	}

static void ARX_GLAPIENTRY callback(GLenum source, GLenum type, GLuint id,                                    GLenum severity, GLsizei length,                                    const GLchar * message, const void * userParam) {		ARX_UNUSED(length);	ARX_UNUSED(userParam);		std::ostringstream buffer;		const GLchar * end = message + std::strlen(message);	while(end != message && (*(end - 1) == '/r' || *(end - 1) == '/n')) {		end--;	}		buffer << sourceToString(source) << " " << typeToString(type) << " #"<< id << ": ";	buffer.write(message, end - message);		switch(severity) {	case GL_DEBUG_SEVERITY_HIGH_ARB:		LogError << buffer.str();		break;	case GL_DEBUG_SEVERITY_MEDIUM_ARB:		LogWarning << buffer.str();		break;	case GL_DEBUG_SEVERITY_LOW_ARB:		LogInfo << buffer.str();		break;	default:		break;	}}

void CriticalErrorDialog::log(const Source & file, int line, Logger::LogLevel level,                              const std::string & str) {	ARX_UNUSED(file), ARX_UNUSED(line);		if(level == Logger::Critical && errorString.empty()) {		errorString = str;	}}

INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR lpCmdLine,                   INT nCmdShow) {	ARX_UNUSED(hInstance);	ARX_UNUSED(hPrevInstance);	ARX_UNUSED(lpCmdLine);	ARX_UNUSED(nCmdShow);		WindowsMain init;		return utf8_main(init.argc, init.argv);}

bool CrashHandler::setNamedVariable(const std::string & name, const std::string & value) {#ifdef HAVE_CRASHHANDLER    if(!isInitialized()) {        return false;    }    return gCrashHandlerImpl->setNamedVariable(name, value);#else    ARX_UNUSED(name), ARX_UNUSED(value);    return false;#endif}

bool ErrorReport::GetCrashDump(const fs::path & fileName) {	#if ARX_PLATFORM == ARX_PLATFORM_WIN32	bool bHaveDump = false;	if(fs::exists(m_pCrashInfo->miniDumpTmpFile))	{		fs::path fullPath = m_ReportFolder / fileName;		if(fs::rename(m_pCrashInfo->miniDumpTmpFile, fullPath))		{			AddFile(fullPath);			bHaveDump = true;		}	}		return bHaveDump;	#else //  ARX_PLATFORM != ARX_PLATFORM_WIN32		ARX_UNUSED(fileName);		// TODO: Write core dump to 	// fs::path fullPath = m_ReportFolder / fileName;		return getCrashDescription();	#endif	}

void MassIncinerateSpell::Update(float timeDelta){	ARX_UNUSED(timeDelta);		if(ValidIONum(m_caster)) {		ARX_SOUND_RefreshPosition(m_snd_loop, entities[m_caster]->pos);	}	}

void Thread::setPriority(Priority priority) {		arx_assert(priority >= Lowest && priority <= Highest);		BOOL ret = SetThreadPriority(thread, windowsThreadPriorities[priority - Lowest]);	arx_assert(ret);	ARX_UNUSED(ret);}

bool getSystemConfiguration(const std::string & name, std::string & result) {	#ifdef ARX_HAVE_WINAPI		if(getRegistryValue(HKEY_CURRENT_USER, name, result)) {		return true;	}		if(getRegistryValue(HKEY_LOCAL_MACHINE, name, result)) {		return true;	}	#else	ARX_UNUSED(name), ARX_UNUSED(result);#endif		return false;}

void ScreenshotWidget::paintEvent(QPaintEvent * event){	ARX_UNUSED(event);	QPainter p(this);	p.setRenderHint(QPainter::SmoothPixmapTransform);	QPixmap scaledPixmap = m_pixmap.scaled(size(), Qt::KeepAspectRatio);	p.drawPixmap(0, 0, scaledPixmap);}

	void onChangedRenderer(int pos, const std::string & str) {		ARX_UNUSED(str);				switch(pos) {			case 0:  config.window.framework = "auto"; break;			case 1:  config.window.framework = "SDL";  break;			default: config.window.framework = "auto"; break;		}	}

static EERIE_3DOBJ * TheoToEerie_Fast(const res::path & texpath, const res::path & file, bool pbox) {		EERIE_3DOBJ * ret = ARX_FTL_Load(file);	if(ret) {		if(pbox) {			EERIE_PHYSICS_BOX_Create(ret);		}		return ret;	}	#if !BUILD_EDIT_LOADSAVE	ARX_UNUSED(texpath);#else		ret = GetExistingEerie(file);	if(ret) {		ret = Eerie_Copy(ret);	}		if(!ret) {				size_t size = 0;		char * adr = resources->readAlloc(file, size);		if(!adr) {			LogWarning << "Object not found: " << file;			return NULL;		}				ret = TheoToEerie(adr, size, texpath, file);		if(!ret) {			free(adr);			return NULL;		}				EERIE_OBJECT_CenterObjectCoordinates(ret);		free(adr);	}		CreateNeighbours(ret);	EERIEOBJECT_AddClothesData(ret);	KillNeighbours(ret);		if(ret->cdata) {		EERIE_COLLISION_SPHERES_Create(ret); // Must be out of the Neighbours zone	}		if(pbox) {		EERIE_PHYSICS_BOX_Create(ret);	}		ARX_FTL_Save(fs::paths.user / file.string(), ret);	#endif // BUILD_EDIT_LOADSAVE		return ret;}

bool Win32Window::initialize(const std::string & title, Vec2i size, bool fullscreen,                             unsigned depth) {	ARX_UNUSED(depth);		if(!registerWindowClass()) {		LogError << "Failed to register the Win32 window class";		return false;	}		DWORD windowStyle = fullscreen ?  (WS_POPUP | WS_VISIBLE) : WS_OVERLAPPEDWINDOW;	DWORD windowExtendedStyle = WS_EX_APPWINDOW;		RECT rcWnd;	SetRect(&rcWnd, 0, 0, size.x, size.y);	BOOL hasMenu = GetMenu(m_hWnd) != NULL;	if(AdjustWindowRectEx(&rcWnd, windowStyle, hasMenu, windowExtendedStyle) != TRUE) {		LogError << "AdjustWindowRectEx() failed";		return false;	}		// Bound the window size to the desktop	HWND hWndDesktop = GetDesktopWindow();	RECT rcDesktop;	GetWindowRect(hWndDesktop, &rcDesktop);	LONG maxWidth = rcDesktop.right - rcDesktop.left;	LONG maxHeight = rcDesktop.bottom - rcDesktop.top;		LONG wndWidth = rcWnd.right - rcWnd.left;	LONG wndHeight = rcWnd.bottom - rcWnd.top;	wndWidth = std::min(wndWidth, maxWidth);	wndHeight = std::min(wndHeight, maxHeight);		// Create a window using our window class.	m_hWnd = CreateWindowEx(windowExtendedStyle, m_WindowClass.lpszClassName, "",	                        windowStyle, CW_USEDEFAULT, CW_USEDEFAULT, wndWidth, wndHeight, 	                        0, NULL, (HINSTANCE)GetModuleHandle(NULL), this);	if(!m_hWnd) {		LogError << "Couldn't create window";		return false;	}		if(SetWindowText(m_hWnd, title.c_str()) == TRUE) {		title_ = title;	} else {		LogWarning << "Couldn't change the window's title";	}		ShowWindow(m_hWnd, SW_SHOW);		isVisible_ = true;	isFullscreen_ = fullscreen;	size_ = size;		return true;}

static mode_t dirstat(void * handle, void * entry) {		arx_assert(entry != NULL);	fs::path file = ITERATOR_HANDLE(handle)->path / reinterpret_cast<dirent *>(entry)->d_name;		struct stat buf;	int ret = stat(file.string().c_str(), &buf);	arx_assert_msg(ret == 0, "stat failed: %d", ret); ARX_UNUSED(ret);		return buf.st_mode;}

int SDLCALL SDL2Window::eventFilter(void * userdata, SDL_Event * event) {    ARX_UNUSED(userdata);    // TODO support multiple windows!    if(s_mainWindow && event->type == SDL_QUIT) {        return (s_mainWindow->onClose()) ? 1 : 0;    }    return 1;}

void Lock::lock() {		pthread_mutex_lock(&mutex);		while(locked) {		int rc = pthread_cond_wait(&cond, &mutex);		arx_assert(rc == 0);		ARX_UNUSED(rc);	}		locked = true;	pthread_mutex_unlock(&mutex);}

void MagicSightSpell::Update(float timeDelta){	ARX_UNUSED(timeDelta);		if(m_caster == PlayerEntityHandle) {		Vec3f pos;		ARX_PLAYER_FrontPos(&pos);		ARX_SOUND_RefreshPosition(m_snd_loop, pos);				if(subj.focal > IMPROVED_FOCAL)			subj.focal -= DEC_FOCAL;	}	}

void ColdProtectionSpell::Update(float timeDelta){	ARX_UNUSED(timeDelta);		if(ValidIONum(m_target)) {		Entity *io = entities[m_target];		io->halo.flags = HALO_ACTIVE;		io->halo.color = Color3f(0.2f, 0.2f, 0.45f);		io->halo.radius = 45.f;	}		ARX_SOUND_RefreshPosition(m_snd_loop, entities[m_target]->pos);}

	void onChangedResolution(int pos, const std::string & str) {		ARX_UNUSED(pos);				if(str == AUTO_RESOLUTION_STRING) {			newWidth = newHeight = 0;		} else {			std::stringstream ss(str);			int iX = config.video.resolution.x;			int iY = config.video.resolution.y;			char tmp;			ss >> iX >> tmp >> iY;			newWidth = iX;			newHeight = iY;		}	}

void ErrorReportDialog::onShowFileContent(const QItemSelection& newSelection, const QItemSelection & oldSelection){	ARX_UNUSED(oldSelection);	const QModelIndexList selectedIndexes = newSelection.indexes();	if(selectedIndexes.empty())		return;	const QModelIndex selectedIndex = selectedIndexes.at(0);	if(!selectedIndex.isValid())		return;		fs::path fileName = m_errorReport.GetAttachedFiles()[selectedIndex.row()].path;	QString ext = fileName.ext().c_str();	if(ext == ".txt" || ext == ".log" || ext == ".ini" || ext == ".xml")	{		QFile textFile(fileName.string().c_str());		textFile.open(QIODevice::ReadOnly | QIODevice::Text);				QByteArray data;		data = textFile.readAll();				ui->fileViewText->setText(QString::fromUtf8(data));		ui->stackedFileViews->setCurrentIndex(0);	}	else if(ext == ".jpg" || ext == ".jpeg" || ext == ".bmp" || ext == ".png" || ext == ".gif")	{		m_fileViewImage.load(fileName.string().c_str());		ui->stackedFileViews->setCurrentIndex(1);	}	else	{		QFile binaryFile(fileName.string().c_str());		binaryFile.open(QIODevice::ReadOnly);				if(binaryFile.size() > 20 * 1024 * 1024) {			ui->stackedFileViews->setCurrentIndex(3);			return;		}		QByteArray data;		data = binaryFile.readAll();		m_fileViewHex.setData(data);		ui->stackedFileViews->setCurrentIndex(2);	}}

static bool is_fd_disabled(int fd) {		ARX_UNUSED(fd);		// Disable the console log backend if output is redirected to /dev/null#ifdef ARX_HAVE_READLINK	static const char * names[] = { NULL, "/proc/self/fd/1", "/proc/self/fd/2" };	char path[64];	ssize_t len = readlink(names[fd], path, ARRAY_SIZE(path));	if(len == 9 && !memcmp(path, "/dev/null", 9)) {		return true;	} else if(len == -1 && errno == ENOENT) {		return true;	}#endif		return false;}

// Obtain the right savegame paths for the platform// XP is "%USERPROFILE%/My Documents/My Games"// Vista and up : "%USERPROFILE%/Saved Games"void defineSystemDirectories(const char * argv0) {		ARX_UNUSED(argv0);		std::string strPath;	DWORD winver = GetVersion();		// Vista and up	if((DWORD)(LOBYTE(LOWORD(winver))) >= 6) {		// Don't hardlink with SHGetKnownFolderPath to allow the game to start on XP too!		typedef HRESULT (WINAPI * PSHGetKnownFolderPath)(const GUID &rfid, DWORD dwFlags,		                                                 HANDLE hToken, PWSTR* ppszPath); 				CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);				PSHGetKnownFolderPath GetKnownFolderPath = (PSHGetKnownFolderPath)GetProcAddress(GetModuleHandleA("shell32.dll"), "SHGetKnownFolderPath");		const GUID FOLDERID_SavedGames = {0x4C5C32FF, 0xBB9D, 0x43b0, {0xB5, 0xB4, 0x2D, 0x72, 0xE5, 0x4E, 0xAA, 0xA4}};				LPWSTR wszPath = NULL;		HRESULT hr = GetKnownFolderPath(FOLDERID_SavedGames, kfFlagCreate | kfFlagNoAlias, NULL, &wszPath);				if(SUCCEEDED(hr)) {			strPath = ws2s(wszPath);		}				CoTaskMemFree(wszPath);		CoUninitialize();	} else if((DWORD)(LOBYTE(LOWORD(winver))) == 5) { // XP		CHAR szPath[MAX_PATH];		HRESULT hr = SHGetFolderPathA(NULL, CSIDL_PERSONAL | CSIDL_FLAG_CREATE, NULL,		                              SHGFP_TYPE_CURRENT, szPath);				if(SUCCEEDED(hr)) {			strPath = szPath; 			strPath += "//My Games";		}	} else {		arx_assert_msg(false, "Unsupported windows version (below WinXP)");	}		if(!strPath.empty()) {		SetEnvironmentVariable("FOLDERID_SavedGames", strPath.c_str());	}}