The GPL is "viral" in that if you use even a smattering of GPLed code, you are required to release ALL of your code as GPL as well.
Not true. Go back and re-read the GPL. You are required to release your code under a license that places no more restrictions on it than the GPL. You must also license the combined work under the GPL. It is, however, completely fine to take a few files of GPL'd code, combine them with some BSDL'd code files (as long as those files are not a derived work of the GPL'd code) and ship the resulting program under the GPL. If someone else takes only the BSDL'd files for use in another project then they are not bound by the GPL.
There are two ways in which the GPL is 'viral'. The first is that you cannot change the license of something that you do not own, so any derived works retain the copyright and license of the original. The second is that the GPL is a distribution license and, if you wish to retain the right to distribute it, then you must not distribute it in a way that does not pass on the freedoms listed in the license (meaning that the combined work must grant all of the permissions as the GPL'd parts).
If they were being pushed out of land they owned, you might have a point.
The problem is when the initial conditions are concentrated ownership. If the hypothetical impoverished country has a feudal system (or similar) where all of the land is owned by a few dozen lords. Now the Americans going over there buy land from the lord in relatively small parcels, allowing him to turn his wealth into liquid form and removing the land that his serfs lived on. So what do the serfs do? They didn't own the land and they're now displaced. They weren't lucky enough to be born owning land so they get nothing.
It's not like most of the people in the original poster's example chose not to own a house. They rent because they didn't inherit enough wealth to own somewhere to live.
"Smart pointers" are great -- if you don't care about performance (in which case, why are you not using Java?). If the object is owned by one thread, it's just sloppy to put in the overhead of smart pointers to make your life easy.
If an object has a single unique owner, then std::unique_ptr has no run-time overhead and will ensure that the object is correctly deleted even in the presence of exceptions. I agree with the grandparent: any object that isn't allocated on the stack should be created with std::make_shared or std::make_unique.
making the code run faster qualifies if it's not running fast enough yet
And then only if backed up by realistic macrobenchmarks. There are a lot of things in C++ that have interesting performance characteristics (templates allow more inlining, so make microbenchmarks faster but can cause you to run out of i-cache and make the whole program slower, virtual functions prevent inlining unless the compiler can do devirtualisation, but are actually slightly faster to call than cross-library calls via a PLT if they're not inlined). Generally, algorithmic improvements will make a bigger difference than any language feature. The main reason for using templates should be to eliminate copy-and-paste coding, not to improve performance.
for the vast majority of the Chinese people, over 90%, do not believe in the effectiveness of the rhino horns
So that's a target market of only 136 million?
with the exception of those living in the Hong Kong and surrounding region (mainly Guangzhou)
Oh, and they're only concentrated in one of the wealthiest areas? Definitely not a problem then.