function-calls

What's the most elegant way of performing a delayed (and therefore also asynchronous) functional call using C++11, lambdas and async? Suggested naming: delayed_async . Reason for asking is that I want a GUI alert light to be switched off after given time (in this case one second) without blocking the main (wxWidgets main loop) thread of course. I've use wxWidgets' wxTimer for this and I find wxTimer rather cumbersome to use in this case. So that got my curious about how much more convenient this could be implemented if I instead used C++11's async 1 , 2 . I'm aware of that I need to protect

So I have looked here and here and at a few other links mentioned in the first question and I have the following code already: The .cpp file: #include "arp_piping.h" #include <string> #include <iostream> #include <stdio.h> std::string exec(char* cmd, FILE* pipe) { pipe = _popen(cmd, "r"); if (!pipe) return "ERROR"; char buffer[128]; std::string result = ""; while(!feof(pipe)) { if(fgets(buffer, 128, pipe) != NULL) result += buffer; } _pclose(pipe); return result; } The header/linker file: #ifndef ARP_PIPING_H #define ARP_PIPING_H #endif #ifdef __cplusplus #define EXTERNC extern "C" #else

This question is inspired by this one . Consider the code: namespace ns { template <typename T> void swap(T& a, T& b) { using namespace std; swap(a, b); } } After some test with GCC, I found that swap(a, b); resolves to 1) std::swap if T has overloaded std::swap (e.g., standard container types) 2) ns::swap otherwise, leading to infinite recursion. So, it seems that the compiler will first try to find a match in the namespace ns . If a match is found, the search ends. But this is not the case when ADL comes in, in which case, std::swap is found anyway. The resolution process seems to be

I would like to know the best way to detect when a method or function is directly called through the console. As far as I currently understand, it's not possible to directly detect it on identical function calls, but using the .call() and .apply() methods of a function I can pass additional data through the this object. Given the following code structure: (function(){ var Player = {money: 0}; window.giveMoney = function(amount){ if (this.legit !== true) throw new Error("Don't try to cheat!"); Player.money += amount; } })(); I could call the function using window.giveMoney.call({legit: true},

In C++ FAQ : Assuming a typical C++ implementation that has registers and a stack, the registers and parameters get written to the stack just before the call to g(), then the parameters get read from the stack inside g() and read again to restore the registers while g() returns to f(). regarding the nested function call void f() { int x = /*...*/; int y = /*...*/; int z = /*...*/; ...code that uses x, y and z... g(x, y, z); ...more code that uses x, y and z... } 1/ Are all implementation of C++ with registers and stack? Does it mean: implementation dependent on compiler/processor/computer