#include <iostream> class Base { public: virtual void message1(){ std::cout << "Base message1" << std::endl; } virtual void message2(std::string param = "Base message2"){ std::cout << param << std::endl; } }; class Derived : public Base { public: virtual void message1(){ std::cout << "Derived message1" << std::endl; } virtual void message2(std::string param = "Derived message2"){ std::cout << param << std::endl; } }; int main(){ Derived d; Base *base = &d; base->message1(); base->message2(); return 0; }If you compile this with g++ and run the produced binary you'll get the following output:
Derived message1 Base message2At first glance this might look a little confusing. It seems like the correct overloaded function is only called for message1 but not for mesage2. However, if you change the function bodies as follows, you can see that the correct function is called both times:
class Base { public: virtual void message1(){ std::cout << "Base::message1 Base message1" << std::endl; } virtual void message2(std::string param = "Base message2"){ std::cout << "Base::message2 " << param << std::endl; } }; class Derived : public Base { public: virtual void message1(){ std::cout << "Derived::message1 Derived message1" << std::endl; } virtual void message2(std::string param = "Derived message2"){ std::cout << "Derived::message2 "<< param << std::endl; } };
Derived::message1 Derived message1 Derived::message2 Base message2As you can see, the correct overloaded functions of the derived class are called in both cases. The main problem stems from the default parameter for message2. Default parameters for C++ functions are resolved at compile time depending on the static type (here: Base), whereas the correct function is determined from the dynamic type (here: Derived). As a rule of thumb, you should never change the values for default parameters in inherited functions. Although it's legal and the result is well defined, doing so will only lead to confusion and subtle errors. Another approach to avoid this issue is to abstain from using default parameters for virtual functions at all. If you want to know more about this an many other quirks of C++ you should take a look at Scott Meyer's book Effective C++. ]]>
svn status | grep ^M | awk '{print $2}' | while read l; do echo "****** $l ******"; svn diff "$l" ; read tmp; done
As you will notice, this doesn't really work - the two read commands take turns in reading the output of svn status.
One elegant solution for this includes the use of the shell builtin exec:
#!/bin/bash
exec 3<&0
svn status | grep ^M | awk '{print $2}' | while read l; do echo "****** $l ******"; svn diff "$l" | less ; read tmp <&3 ;done
The line following the shebang creates a copy of the current
stdin
(filehandle 0) and assigns it to a new filehandle 3 i.e. 0 and 3 both will read commands from the keyboard being the default in a
newly created shell. In the next line filehandle 0 is redirected several times (remember: a | b redirects the stdout of a
into the stdin of b), so the first read reads its lines from the awk command. The second read, however, reads its input from
filehandle 3 which still has the value that filehandle 0 had in the beginning of the script, i.e. it reads the keyboard input
(I also piped svn diff through less, but that's just a small enhancement which is unrelated to the main problem).If the name was the last link to a file but any processes still have the file open the file will remain in existence until the last file descriptor referring to it is closed.In other words, the flashplayer creates a new file in /tmp, deletes the file right away with unlink but keeps the filehandle open, so the flashplayer process may still access the file. This however, may lead to confusion - df reveals that the free space on /tmp is shrinking, while du doesn't show any growing files at all. One way to fix this issue is simple - use library preloading to overwrite the original unlink function used by firefox: Download the tgz-archive, unpack it and make it. If the previous steps were successful, you should now have a file unlink.so available. The last step is to tell firefox (or more precisely the dynamic linker) to use the unlink function from this file rather than the one from your C Standard library:
LD_PRELOAD=/path/to/unlink.so firefoxThe LD_PRELOAD environment variable tells the dynamic linker to search for libraries in non-standard locations - in this case in our library file unlink.so. You might want to add an alias like the following to your environment, but for obvious reasons you shouldn't globally export LD_PRELOAD.
alias ff="LD_PRELOAD=/path/to/unlink.so firefox"Yet there is one drawback with this solution: even if you close firefox, the files in /tmp will persist, so you may want to delete them manually from time to time...]]>
for file in *; do echo "Touching $file"; touch "$file"; doneThis will touch every file in the current directory and tell you about it (not really a real world example, but you might get the point). However sometimes you'd like to also work on the files in all subdirectories - two popular solutions for this include the find command or recursion. As a rule, most users forget/don't know about the Bash's globstar option. If set (shopt -s globstar), you may use the following construct to also touch the files found in all subdirectories.
for file in **/*; do echo "Touching $file"; touch "$file"; doneJust want to touch all mp3 files? Here you go:
for file in **/*.mp3; do echo "Touching $file"; touch "$file"; done
user@host /var/tmp $ mkdir example_ user@host /var/tmp $ cd example -bash: cd: example: No such file or directory user@host /var/tmp $ shopt -s cdspell user@host /var/tmp $ cd example example_ user@host /var/tmp/example_ $autocd does a very similar job - if you issue a valid directory name without the prepended cd, you will automatically change to that directory.
p=$(which perl); mkdir -p ~/.vim/skeletons; cat << EOF > ~/.vim/skeletons/skeleton.pl #!$p use strict; use warnings; EOF
autocmd BufNewFile *.pl 0r ~/.vim/skeletons/skeleton.pl | :normal G
autocmd FileType perl set makeprg=perl\ -c\ %\ $*By adding this to your ~/.vimrc, :make will no longer invoke make file but perl -c file instead, when you're editing a Perl script. As usual, Perl is just an example - i.e. Ruby programmers might use ruby -c or the like.
map Y y$
r=$(cat /sys/class/net/eth0/statistics/rx_bytes) ; while [ 1 ]; do n=$(cat /sys/class/net/eth0/statistics/rx_bytes); d=$(((n-r) / 1024 ));r=$n; echo "$d KB/s"; sleep 1;done