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

void Translation::run(vector<string> pArgParam,string input, string output){	unused(pArgParam);	ImagePNG* img = new ImagePNG();	img->load(input);	double start = Data::get_time();	cout << &img << endl;	translation(img,atoi(pArgParam[0].c_str()),atoi(pArgParam[1].c_str()), new Color(0,0,0,255));	if (Data::CHRONO)	cout << description<<" effectue en " << 1000*(Data::get_time() - start)<<" ms"<<endl;	img->save(output);}

int WINAPI WinMain    (HINSTANCE hInstance    ,HINSTANCE hPrevInstance    ,LPSTR     lpCmdLine    ,int       nCmdShow    )#endif // LMI_MSW defined.{    // (Historical notes.) Using wx-2.5.1 and mpatrol-1.4.8, both    // dynamically linked to this application built with gcc-3.2.3,    // three memory leaks are reported with:    //   MPATROL_OPTIONS='SHOWUNFREED'    // It's easier to trace them with:    //   MPATROL_OPTIONS='LOGALL SHOWUNFREED USEDEBUG'    // Two are apparently mpatrol artifacts traceable to symbols:    // [space follows leading underscores in reserved names]    //   "_ _ _ mp_findsource"    //   "_ _ _ mp_init"    // The third is traceable in 'mpatrol.log' with 'USEDEBUG' to    //   Skeleton::GetEventHashTable() const    // (although stepping through the code in gdb suggests it's really    // WinMain(), and mpatrol or libbfd just got the symbol wrong)    // and seems to be triggered the first time the program allocates    // memory. The next line forces that to occur here; otherwise,    // tracing this 'leak' becomes cumbersome and mysterious.    std::string unused("Seems to trigger initialization of something.");    int result = EXIT_FAILURE;    try        {        initialize_application();        initialize_filesystem();#ifndef LMI_MSW        result = wxEntry(argc, argv);#else // LMI_MSW defined.        result = wxEntry(hInstance, hPrevInstance, lpCmdLine, nCmdShow);#endif // LMI_MSW defined.        }    catch(...)        {        try            {            report_exception();            }        catch(...)            {            safely_show_message("Logic error: untrapped exception.");            }        }    fenv_validate();    return result;}

static void terraform_default(struct rawmaterial *res, const region * r){#define SHIFT 70  double modifier =    1.0 + ((rng_int() % (SHIFT * 2 + 1)) - SHIFT) * ((rng_int() % (SHIFT * 2 +        1)) - SHIFT) / 10000.0;  res->amount = (int)(res->amount * modifier);  /* random adjustment, +/- 91% */  if (res->amount < 1)    res->amount = 1;  unused(r);}

/* This function drops those values in the history which are older   than the specified age of the history instance. */void history::drop (void) {  nr_double_t f = first ();  nr_double_t l = last ();  if (age > 0.0 && l - f > age) {    int r, i = leftidx ();    for (r = 0; i < t->getSize (); r++, i++)      if (l - t->get (i) < age)	break;    r += unused () - 2; // keep 2 values being older than specified age    if (r > 127) values->drop (r);  }}

static void drawPixel(int mode,int x,int y,unsigned short color){    unused(mode);    unsigned int pos = y * 640 + x;    unsigned short _page = pos >> 16;    /*! FIXME : 暂时将就下吧, !*/    if(_page != page){        page = _page;        selectPlane(page << 2);    }    ((unsigned char *)0xa0000)[pos & 0xffff] = color;}

static void ollrb_itr_set_ref(iterator citr, const void* n_ref) {	/* llrb does not permit to set ref, which would destroy the inner data structure. */	/*	struct ollrb_itr* itr   = (struct ollrb_itr*)citr;	struct ollrb_node* node = NULL;	dbg_assert(itr->__cast == ollrb_itr_cast);	dbg_assert(itr->__current != NULL);	node = container_of(itr->__current, struct ollrb_node, link);	node->reference = n_ref;	*/	unused(citr);	unused(n_ref);	dbg_assert(false);	return;}

Color TimeWarpSynchronousGVTManager::sendEventUpdate(std::shared_ptr<Event>& event) {    unused(event);    Color color = color_.load();    if (color == Color::WHITE) {        white_msg_count_++;    }    return color;}

void Difference::run(vector<string> pArgParam,string input, string output){	unused(pArgParam);	ImagePNG* img = new ImagePNG();	img->load(input);	ImagePNG* img2 = new ImagePNG();	img2->load(pArgParam[0]);	double start = Data::get_time();	difference(img, img2);	if (Data::CHRONO)	cout << description<<" effectue en " << 1000*(Data::get_time() - start)<<" ms"<<endl;	img->save(output);}

vector<int> findSubstring(string s, vector<string> &dict){    /*    You are given a string, S, and a list of words, L, that are all of the same length.    Find all starting indices of substring(s) in S that is a concatenation of each word in L exactly once and without any intervening characters.    For example, given:    S: "barfoothefoobarman"    L: ["foo", "bar"]    You should return the indices: [0,9].    (order does not matter).    */    size_t wordLength = dict.front().length();    size_t catLength = wordLength * dict.size();    vector<int> result;    if (s.length() < catLength)    {        return result;    }    unordered_map<string, int> wordCount;    for (auto const& word : dict)    {        ++wordCount[word];    }    for (auto i = begin(s); i <= prev(end(s), catLength); ++i)    {        unordered_map<string, int> unused(wordCount);        for (auto j = i; j != next(i, catLength); j += wordLength)        {            auto pos = unused.find(string(j, next(j, wordLength)));            if (pos == unused.end() || pos->second == 0)            {                break;            }            if (--pos->second == 0)            {                unused.erase(pos);            }        }        if (unused.size() == 0)        {            result.push_back(distance(begin(s), i));        }    }    return result;}

inline voidvirtual_free(void *ptr, u32 size){#if PLATFORM_WINDOWS    unused(size);    VirtualFree((void *)ptr, 0, MEM_RELEASE);#else    msync(ptr, size, MS_SYNC);    munmap(ptr, size);#endif}

static void pidfile_close(void){    if (pidfile) {        if (daemon_process) {            rewind(pidfile);            unused(ftruncate(fileno(pidfile), (off_t)0));        }        fclose(pidfile);        pidfile = NULL;    }}

void Controller::update(unsigned long long timestamp, int midi_value) {    unused(timestamp);    switch (type) {    case TYPE_LINEAR:	if (midi_value > midi_midpoint) {	    midi_value -= midi_midpoint;	    value = value_midpoint + (value_max - value_midpoint) * midi_value / range_divisor_upper;	} else {	    value = value_min + (value_midpoint - value_min) * midi_value / range_divisor_lower;	}    }}

MMError dylan_mm_register_thread(void *stackBot){  gc_teb_t gc_teb = current_gc_teb();  update_runtime_thread_count(1);  zero_allocation_counter(gc_teb);  unused(stackBot);  return 0;}

nsresultnsJSUtils::EvaluateString(JSContext* aCx,                          JS::SourceBufferHolder& aSrcBuf,                          JS::Handle<JSObject*> aScopeObject,                          JS::CompileOptions& aCompileOptions,                          void **aOffThreadToken){  EvaluateOptions options;  options.setNeedResult(false);  JS::RootedValue unused(aCx);  return EvaluateString(aCx, aSrcBuf, aScopeObject, aCompileOptions,                        options, &unused, aOffThreadToken);}

Timer::Timer(){	if (m_freq == 0.0)		// m_freq not initialized yet ?	{		LARGE_INTEGER li;		auto res = QueryPerformanceFrequency(&li);	    bwem_assert(res);		unused(res);		m_freq = li.QuadPart / 1000.0;	}	Reset();}

/** * @brief Write message to file * @copydetails ll_open_cb_t */static int file_open(const char *name, enum ll_level level, struct url *u,	void **priv) {	unused(name);	unused(level);	assert(u);	if (u->username ||		u->password ||		u->hostname ||		u->port ||		!u->path ||		u->query ||		u->fragment) {		return (-1);	}	if (!(*priv = fopen(u->path, "w"))) {		return (-1);	}	return (0);}

void * cookt(void * data){    unused(data);    while(1)    {        sem_wait(&cookpillow);                        printf("COOK %d [+%d]/n",portions,M);            usleep(rand()%90+10);            portions = M;            //printf("READY/n");        sem_post(&shout);    }}

void fractional_progress::init(stream_size_type range) {    unused(range);#ifndef TPIE_NDEBUG    if (m_init_called) {        std::stringstream s;        s << "init() was called on a fractional_progress for which init had already been called.  Subindicators were:" << std::endl;        s << sub_indicators_ss();        TP_LOG_FATAL(s.str());        s.str("");        tpie::backtrace(s, 5);        TP_LOG_DEBUG(s.str());        TP_LOG_FLUSH_LOG;    }    m_init_called=true;#endif    if (m_pi) m_pi->init(23000);}

//------------------------------------------------------------------------------//!voidSocket::blocking( bool v ){#if BASE_SOCKET_USE_BSD   int f = fcntl( _impl->_sock, F_GETFL, 0 );   if( v )   {      fcntl( _impl->_sock, F_SETFL, f | O_NONBLOCK );   }   else   {      fcntl( _impl->_sock, F_SETFL, f & ~O_NONBLOCK );   }#elif BASE_SOCKET_USE_WINSOCK   unused(v);#else#endif}

    bool worldUpdatorAsync(uint64_t dt_nanos)    {        unused(dt_nanos);        try {            update();        }        catch(const std::exception& ex) {            //Utils::DebugBreak();            Utils::log(Utils::stringf("Exception occurred while updating world: %s", ex.what()), Utils::kLogLevelError);        }        catch(...) {            //Utils::DebugBreak();            Utils::log("Exception occurred while updating world", Utils::kLogLevelError);        }        return true;    }

static UINT __Format(	OUT LPTSTR* ppOutput,	OUT UINT* pLen,	IN LPCTSTR format, 	IN va_list& args){	UINT len(0);    if (format)    {		va_list newargs;        va_copy(newargs, args);        		// Figure out the length. If we were given 		// a valid pointer that's long enough, use it		// otherwise we need to reallocate it.		len = VSCPRINTF(format, newargs)+1;		if (len > *pLen)		{			// Delete the buffer            ARRAY_DELETE(*ppOutput);						// Resize the buffer.			size_t unused(0);			__Alloc(len, ppOutput, &unused);			*pLen = len;		}		// Fill the buffer.		if (*ppOutput)		{			SPRINTFNS(*ppOutput, *pLen, format, newargs);		}    }	//else	//{	//	YOU'RE GETTING A NULL POINTER BACK!	//}	return len;}

template <size_t N, typename F> Vc_ALWAYS_INLINE void benchmark(F &&f){    TimeStampCounter tsc;    auto cycles = tsc.cycles();    cycles = 0x7fffffff;    for (int i = 0; i < 100; ++i) {        tsc.start();        for (int j = 0; j < 10; ++j) {            auto C = f();            unused(C);        }        tsc.stop();        cycles = std::min(cycles, tsc.cycles());    }    //std::cout << cycles << " Cycles for " << N *N *(N + N - 1) << " FLOP => ";    std::cout << std::setw(19) << std::setprecision(3)              << double(N * N * (N + N - 1) * 10) / cycles;    //<< " FLOP/cycle (" << variant << ")/n";}

// To tylko test. Dzieki write mozna sprawdzic, ze rzeczywiscie// nasza skrzynka zachowuje sie tak jak powinnavoid * t2(void *data){    unused(data);    char buffer[STRING_LENGTH];    sprintf(buffer,"/tSTART/n");    write(1,buffer,strlen(buffer));    sprintf(buffer,"/tPOST/n");    write(1,buffer,strlen(buffer));    cs_post("/sem");    write(1,buffer,strlen(buffer));    cs_post("/sem");    write(1,buffer,strlen(buffer));    cs_post("/sem");    write(1,buffer,strlen(buffer));    cs_post("/sem");    sprintf(buffer,"/tSTOP/n");    write(1,buffer,strlen(buffer));    return NULL;}

}static int list_close(URLContext *h){	struct list_mgt *mgt = h->priv_data;	struct list_item *item,*item1;	if(!mgt)return 0;	item=mgt->item_list;	if(mgt->cur_uio!=NULL)		url_fclose(mgt->cur_uio);	while(item!=NULL)		{		item1=item;		item=item->next;		av_free(item1);			}	av_free(mgt);	unused(h);	return 0;

static int list_close(URLContext *h){	struct list_mgt *mgt = h->priv_data;	struct list_item *item,*item1;	if(!mgt)return 0;	item=mgt->item_list;	if(mgt->cur_uio!=NULL)		url_fclose(mgt->cur_uio);	while(item!=NULL)		{		item1=item;		item=item->next;	if(item->ktype == KEY_AES_128){			if(item->key_ctx){			av_free(item->key_ctx);		}		if(item->crypto){			if(item->crypto->aes)				av_free(item->crypto->aes);			av_free(item->crypto->aes);		}			}		av_free(item1);			}	int i;	for (i = 0; i < mgt->n_variants; i++) {	    struct variant *var = mgt->variants[i];        	    av_free(var);	}	av_freep(&mgt->variants);	mgt->n_variants = 0;	if(NULL!=mgt->prefix){		av_free(mgt->prefix);		mgt->prefix = NULL;	}	av_free(mgt);	unused(h);	return 0;}

void * t1(void * data){    unused(data);    char buffer[STRING_LENGTH];    sprintf(buffer,"START/n");    write(1,buffer,strlen(buffer));    sprintf(buffer,"WAIT/n");    write(1,buffer,strlen(buffer));    cs_wait("/sem");    write(1,buffer,strlen(buffer));    cs_wait("/sem");    write(1,buffer,strlen(buffer));    cs_wait("/sem");    write(1,buffer,strlen(buffer));    cs_wait("/sem");    cs_wait("/sem");    sprintf(buffer,"STOP/n");    write(1,buffer,strlen(buffer));    return NULL;}

/* * Read STDIN and send to the bufferevent. */static void v4c_send_stdin(evutil_socket_t fd, short what, void *ctx){    struct bufferevent *bev = ctx;    char data[1024];    int rc;    unused(what);    if (!bev) {        ERR("No client connected yet.");        return;    }    rc = read(fd, data, sizeof (data));    if (rc < 0) {        ERR("read() failed (%s).", strerror(errno));        return;    }    data[rc] = '/0';    evbuffer_add(bufferevent_get_output(bev), data, rc);}

int readAbs(void *buf, int sectors, int drive, int track, int head, int sect){    int rc;    int ret = -1;    int tries;        unused(sectors);    tries = 0;    while (tries < 5)    {        rc = BosDiskSectorRead(buf, 1, drive, track, head, sect);        if (rc == 0)        {            ret = 0;            break;        }        BosDiskReset(drive);        tries++;    }    return (ret);}

void ViBuffer::execute(ViFunctorParameter *data){	QMutexLocker locker(&mMutex);	ViBufferStream *object = dynamic_cast<ViBufferStream*>(data);	if(object != NULL)	{		if(object->mode() == QIODevice::ReadOnly)		{			--mReadStreamCount;		}		else if(object->mode() == QIODevice::WriteOnly)		{			--mWriteStreamCount;			if(mWriteStreamCount == 0)			{				locker.unlock();				emit unused();			}		}	}}

void EngineView::update_selection() {	if(!ImGui::IsWindowHovered() || !ImGui::IsMouseClicked(0)) {		return;	}	Transformable* selected = nullptr;	float score = std::numeric_limits<float>::max();	for(const auto& tr : context()->scene().scene().static_meshes()) {		auto [pos, rot, scale] = tr->transform().decompose();		unused(rot);		float radius = tr->radius() * std::max({scale.x(), scale.y(), scale.z()});		float sc = (pos - _picked_pos).length() / radius;		if(sc < score) {			selected = tr.get();			score = sc;		}	}	context()->selection().set_selected(selected);}