Q:

Why other languages don't have automatic garbage collection similar as that of the Java Garbage Collector?

What are the reason/s behind other languages not having a Garbage Collector?
Why garbage collection is not built-in for these other languages? why do programmers given the responsibility to collect?

A:

Reasons not to have garbage collection:

Really efficient collectors weren't developed until around 1985–1990.  Languages designed before that time, if efficiency was a goal, don't have garbage collection.  Examples: Ada, C, Fortran, Modula-2, Pascal.
Bjarne Stroustrup thinks it is better language design to make every cost explicit, and "not to pay for features you don't use."  (See his papers in the 2nd and 3rd ACM Conferences on the History of Programming Languages.)  Therefore C++ doesn't have garbage collection.
Some research languages use other ideas (regions, fancy type systems) to manage memory explicitly, yet safely.  These ideas have special promise for problems such as device drivers, where you may not be able to afford to allocate, or for real-time systems, where memory costs must be very predictable.

A:

The hardware has no garbage collector (there was some hardware which had some elementary support for forwarding pointers, a feature useful in the construction of some garbage collectors, but that's far from a "GC in hardware"). Correspondingly, assembly has no GC. Assembly is a "programming language" (albeit one of the closest to the bare metal), so their you go: in the wide spectrum of existing programming languages, some will not have a GC.
It so happens that an efficient GC is not something which is easy to implement. Good algorithms for that have been long in the making. More importantly, most good GC algorithms are good because they perform some elaborate operations such as moving data elements in RAM; this is necessary for the "realtime GC" which offer guarantees on maximum time spent for allocation (you cannot have such guarantees when there is fragmentation, and you cannot avoid fragmentation without moving objects in RAM). When an object is moved, all pointers to that object must be automatically adjusted, which can be done only if the programming language offers strong, unescapable types. For instance, this cannot be done with C or C++. In C, it is legal to print out the bytes which encode a pointer value, and then have the user type them back. The GC cannot change the brain of the user when it moves an object...
So in practice, languages without strong types are GC-less. This includes C, C++, Forth, all kinds of assembly-with-extensions languages... This does not prevent some people to write GC implementations for such languages, e.g. Hans Boehm's GC for C and C++. It does mean, though, that the GC may fail with (weird) programs which are nominally "legal", as far as the language standard is concerned.
There are also languages with strong types but without a GC, either because their designers did not believe in it, or believed they could do better without, or cringed from the extra code size (for instance, Javacard, the Java for smartcards, is GC-less, because fitting a GC in an environment with 8 kB of code and 512 bytes of RAM is not easy).
Finally, among the thousands of programming languages which have been designed ("once per week since the sixties", I was once told), some are the result of late-at-night conversations after too much alcohol, so it cannot be assumed that every feature or non-feature of all programming languages is the result of balanced rational thinking.

A:

"Other languages" do - this question is tagged C# and the .NET CLR most definitely does perform automatic garbage collection.
I can think of a few reasons for C++ not to have it:

All existing code in C++ uses explicit memory management, so implementing garbage collection would be a breaking change;
By the same token. C++ programmers are already accustomed to explicit memory management, so garbage collection isn't that important a feature;
Good garbage collection algorithms are fairly new, and C++ predates them by quite a bit.  Garbage collection is a horizontal feature and the language designers would have to make major (and complicated) changes to the spec.  Put simply, it's harder to bolt on a garbage collector to an existing language than it is to design it into the language from the beginning, as it was with .NET and Java.
Java runs in a Virtual Machine and .NET uses something similar, whereas C++ deals with native code.  GC is much easier to reason about in the former case.
C++ is often used for applications that need to run under tight memory requirements (i.e. embedded systems), and in these instances, explicit memory management is a necessity.  I suppose some sort of "opt-in" GC could solve this, but that is even harder for the language designers to implement properly.

