Javascript facilitates asynchronous programming. Is Asynchronous programming using callbacks instead of uniflow, possible with C? (or C++)
PS: its evident that C# 5.0 has implemented it.
Edit:
What are the frameworks similar to nodejs in C and in C++?
Edit 2: Asynchronous programming helps to scale users up without need of multithreading (which is important for large user applications) why may a callback based asynchronous approach for a regular application (with only 100s of users)?
You may need to manipulate threads, function pointers, functors, lambdas or you can use a dedicated library. Well, everything can be done in C++.
In your comments you are speaking about NodeJS. I guess you want is an asynchronous library for files, networks...
In this case you may take a look at Boost.Asio which ease the use of asynchronous programming in C++.
Here is quick example, partly from their documentation:
class server
{
public:
server(boost::asio::io_service& io_service,
const tcp::endpoint& endpoint)
: acceptor_(io_service, endpoint)
{
do_accept();
}
private:
void do_accept()
{
acceptor_.async_accept(socket_,
[this](boost::system::error_code ec)
{
if (!ec)
{
// Do your stuff here with the client socket when one arrive.
}
do_accept(); // Start another async call for another client.
});
// Your server can do some other stuff here without waiting for a client.
}
tcp::acceptor acceptor_;
};
This is a basic server that accepts some clients asynchronously. The function tcp::acceptor::asyn_accept will return imediatly and call later the callback when a client connect. In our case, this callback is a lambda function; a new feature from C++11.
this) when server is destructed before stopping the io_service.To implement callbacks the concepts needed are: function pointers (so that a routine knows what to callback); re-entrant programming style (a stack for automatic variables and no reliance on global or static vars that might get changed by other code); thread-safe code (e.g., for XP and above Microsoft's C Run Time (CRT) library is thread safe) so that routines like printf will function when entered from a call-back routine and a mainline routine; in some cases a method to serialize critical sections of code.
Also, in theory callbacks can be issued from other threads, so thread-safe code is necessary.
Anyway, notice that these descriptions are OS and language agnostic. A programmer could write C code to implement these concepts, or the programmer could choose a different language. It really depends on the application's requirements.
of course it is. Think of the simple solution: you create a thread that accepts messages from some source (either internal or external), this thread dispatches the messages to a routine in a class or classes depending upon some defined data (maybe a string that says which class to call, or some ID that a plugin registers with the thread, etc).
When this routine completes processing it sends a message back to the main system that, dispatches it as it does with the rest of the system - a plugin doesn't have to be a server process, but can be a socket to a network client, for example.
Net result: async callbacks in both directions. Really simple to implement and no traditional threading issues either. This also has a benefit of running in a single thread, but there's no reason why you can't have a pool of threads that takes messages of the dispatch queue and processes them in parallel, thus scaling in a way that node.js doesn't.
Async programming doesn't really help to scale - in the case of node it just happens to work because node is designed for network programming where lots of small tasks are outweighed by the cost of the network traffic itself.
std::async.asyncin C# enabled asynchronous callbacks for the first time in the language. Async calls can be performed on a single thread as well.