STL (Standard Template Library) Part2

Function Adapters
A function adapter is a function object that enables the combining of function objects with each other, with certain values, or with special function.

The expression bind2nd(greater(), 42) produces a cobmined function object that checks whetehr an int value is greater than 42. In fact, bind2nd transforms a binary function object, such as greater<>(), into a unary function object. Thus, in this example it always calls greater<> with 42 as the second argument.

The following are the list of predefined function adapter classes in STL:
* bind1st(op, value) ==> op(value, param)
* bind2nd(op, value) ==> op(param, value)
* not1(op) ==> !op(param)
* not2(op) ==> !op(param1, param2)

C++ Programming Tips

1. Make your C++ class Final/Sealed ( Class that can not be inherited )

You all knows that final class is inbuilt in java. But in C++ you have to create final class. The trick is to declare destructor as private.

Class Final

{

Public:

Static Final CreateInstance() { ; }

Private:

~Final() { ; }

};

Class DependentClass : Final

{

...

};

Now Error will appear during compilation. Child class can'nt inherit final class.. Because destructor of final class is private.

We can always declare private as constructor of them. But constructor can be overloaded but Destructor can'nt be Overloaded. So to be safe , define Destructor as private rather defining it's constructor.

2. Methods not inherited in C++

C++ inheritance is very similar to a parent-childrelationship. When a class is inherited all the functions and data member are inherited, although not all of them will be accessible by the member functions of the derived class. But there are some exceptions to it too. Some of the exceptions to be noted in C++ inheritance are as follows.

1. The constructor of a base class are not inherited
2. The destructor of a base class are not inherited
3. The assignment operator is not inherited
4. Friend functions and friend classes of the base class are also not inherited.

There are some points to be remembered about C++ inheritance. The protected and public variables or members of the base class are all accessible in the derived class. But a private member variable not accessible by a derived class.

3. Private Inheritance:

Private inheritance does not model an is-a relationship in the same way that public inheritance does. Instead, private inheritance refers to the idea of being "implemented in terms of a".

The key difference is that whereas public inheritence provides a common interface between two classes, private inheritance does not--rather, it makes all of the public functions of the parent class private in the child class. This means that they can be used in order to implement the child class without being accessible to the outside world.

The syntax for private inheritance is almost exactly the same as for public inheritance.
class obj : private implementationDetailOfObj.

4. UTF-8 & C++

A simple, portable and lightweight generic library for handling UTF-8 encoded strings.

Strcoll
The C++ strcoll function compares two strings according to the LC_COLLATE category, which provides specific collating information. This function may fail if either string contains characters outside the domain of the current collating sequence. It is multi-thread safe as long no other thread calls setlocale() while this function is executing. The following steps will help you use the strcoll function in C++.

iconv
The iconv API is the standard programming interface for converting character stringsfrom one character encoding to another in Unix-like operating systems. Initially appearing on the HP-UX operating system, it was standardized within XPG4 and is part of the Single UNIX Specification (SUS).

All recent Linux distributions contain a free implementation of iconv() as part of the GNU C Librarywhich is the C library for current Linux systems. To use it, the GNU glibc localesneed to be installed, which is provided as a separate package, named glibc-locale usually, and is normally installed by default

Mbstowcs

Convert multibyte string to wide-character string.The C multibyte character string mbstris interpreted character by character and translated to its wchar_t equivalent, which is stored in the location pointed by wcstr. The length in characters of the resulting string, not including the ending null-character, is returned.

Wcstombs

Convert wide-character string to multibyte string.The C wchar_t string wcstris interpreted character by character and translated to its multibyte equivalent, which is stored in the location pointed by mbstr. The length in bytes of the resulting multibyte string, not including the ending null-character, is returned.

Mblen

Get length of multibyte character. The size of the multibyte character pointed by pmb is determined, examining at most max bytes.mblen has its own internal shift state, which is altered as necessary only by calls to this function.

Glib
For many applications, C with GLib is an alternative to C++ with STL (see GObject for a detailed comparison).

In computing, GLibrefers to a cross-platform software utility library. It started life as part of the GTK+project, however, before releasing version 2 of GTK+, the project's developers decided to separate non-GUI-specific code from the GTK+ platform, thus creating GLib as a separate product. GLib was released as a separate library so other developers, those that did not make use of the GUI-related portions of GTK+, could make use of the non-GUI portions of the library without the overhead of depending on a full-blown GUI library.

Since GLib is a cross-platform library, applications using it to interface with the operating system are usually portable across different operating systems without major changes.

ICU
The International Component for Unicode (ICU) is a mature, portable set of C/C++ and Java libraries for Unicode support, software internationalization (I18N) and globalization (G11N), giving applications the same results on all platforms.
 

C++ Versions => C++98, C++11, C++14, C++17

C++11 Features:

Threading Library (concurrency):

C++11 has a thread class that represents an execution thread, promises and futures, which are objects that are used for synchronization in a concurrent environment, the async() function template for launching concurrent tasks, and the thread_local storage type for declaring thread-unique data. For a quick tour of the C++11 threading library, read Anthony Williams’ Simpler Multithreading in C++0x.

New Smart Pointer Classes:

C++98 defined only one smart pointer class, auto_ptr, which is now deprecated. C++11 includes new smart pointer classes: shared_ptr and the recently-added unique_ptr. Both are compatible with other Standard Library components, so you can safely store these smart pointers in standard containers and manipulate them with standard algorithms.

C++11 Standard Library:

C++11 includes new container classes (unordered_set, unordered_map, unordered_multiset, and unordered_multimap) and several new libraries for regular expressions, tuples, function object wrapper and more.

Miscellaneous:

1.     Lambda Expressions

2.     Automatic Type Deduction and decltype(auto)

3.     Deleted and Defaulted Functions(default, delete)

4.     nullptr

5.     Delegating Constructors

6.     Rvalue References

ref:

Intel Software Labs - Intel Software & Blogs - http://software.intel.com/
Microsoft Coding Standard Rules - http://msdn.microsoft.com/en-us/library/czefa0ke.aspx

UTF-8 & Unicode FAQ for Unix/Linux - http://www.cl.cam.ac.uk/~mgk25/unicode.html

http://sourceforge.net/projects/utfcpp

http://utfcpp.sourceforge.net/

https://blog.smartbear.com/c-plus-plus/the-biggest-changes-in-c11-and-why-you-should-care/

C++ Strings =>

The Complete Guide to C++ Strings, Part I - Win32 Character Encodings : http://www.codeproject.com/KB/string/cppstringguide1.aspx

The Complete Guide to C++ Strings, Part II - String Wrapper Classes : http://www.codeproject.com/KB/string/cppstringguide2.aspx?fid=11477&df=90&mpp=25&noise=3&sort=Position&view=Quick&fr=126&select=308883

C++ Strings - http://richardbowles.tripod.com/cpp/cpp15.htm

C++ JAVA Interoperability

In-Process Integration
JNI

Out-Process Integration
WebServices
ESB(Mule/OpenESB/ ...)
EAI(ex: Tibco/Corba/...)
RPC
Sockets

Links:

Java C++ Socket Communication Class Code - http://www.keithv.com/project/socket.html

Endianess : Java vs C++ - http://mindprod.com/jgloss/endian.html

Experiences Converting a C++ Communication Software Framework to Java By Prashant Jain and Douglas C. Schmidt - http://www.cs.wustl.edu/~schmidt/C++2java.html

C++/JAVA communication -
http://adtmag.com/reports/article.aspx?editorialsid=618

C++, Java, & XML Processing - http://www.ddj.com/java/184401817

Unix Miscellaneous

1. ipcs provides information on the ipc facilities for which the calling process has read acccess.
The -i option allows a specific resource id to be specified. Only information on this id will be printed.

Options:
-m : shared memory segments
-q : message queues
-s : semaphore arrays
-a : all (this is the default)

2. ipcrm - remove a message queue, semaphore set or shared memory id

Options:
-M shmkey : removes the shared memory segment created with shmkey after the last detach is performed.
-m shmid : removes the shared memory segment identified by shmid after the last detach is performed.
-Q msgkey : removes the message queue created with msgkey.
-q msgid : removes the message queue identified by msgid.
-S semkey : removes the semaphore created with semkey.
-s semid : removes the semaphore identified by semid.

3. swab - swap adjacent bytes (Useful during Porting on Unix Platforms)

#include <unistd.h>
void swab(const void *from, void *to, ssize_t n);

Description:
The swab() function copies n bytes from the array pointed to by from to the array pointed to by to, exchanging adjacent even and odd bytes. This function is used to exchange data between machines that have different low/high byte ordering.

This function does nothing when n is negative. When n is positive and odd, it handles n-1 bytes as above, and does something unspecified with the last byte. (In other words, n should be even.)

4. lsof - A utility which lists open files on a Linux/UNIX system.
glsof - GUI for lsof.

A command meaning "list open files", which is used in many Unix-like systems to report a list of all open files and the processes that opened them.

Open files in the system include disk files, pipes, network sockets and devices opened by all processes. One use for this command is when a disk cannot be unmounted because (unspecified) files are in use. The listing of open files can be consulted (suitably filtered if necessary) to identify the process that is using the files.

5. netstat (network statistics) - A command-line tool that displays network connections (both incoming and outgoing), routing tables, and a number of network interface statistics. It is available on Unix, Unix-like, and Windows NT-based operating systems.

Parameters used with this command must be prefixed with a hyphen (-) rather than a slash (/).

-a : Displays all active TCP connections and the TCP and UDP ports on which the computer is listening.

-b : Displays the binary (executable) program's name involved in creating each connection or listening port. (Windows only)

-e : Displays ethernet statistics, such as the number of bytes and packets sent and received. This parameter can be combined with -s.

-f : Displays fully qualified domain names for foreign addresses.(not available under Windows)

-i : Displays network interfaces and their statistics (not available under Windows)

-n : Displays active TCP connections, however, addresses and port numbers are expressed numerically and no attempt is made to determine names.

-o : Displays active TCP connections and includes the process ID (PID) for each connection. You can find the application based on the PID on the Processes tab in Windows Task Manager. This parameter can be combined with -a, -n, and -p. This parameter is available on Microsoft Windows XP, 2003 Server (not Microsoft Windows 2000)).

-p Windows: Protocol : Shows connections for the protocol specified by Protocol. In this case, the Protocol can be tcp, udp, tcpv6, or udpv6. If this parameter is used with -s to display statistics by protocol, Protocol can be tcp, udp, icmp, ip, tcpv6, udpv6, icmpv6, or ipv6.

-p Linux: Process : Show which processes are using which sockets (similar to -b under Windows) (you must be root to do this)

-r : Displays the contents of the IP routing table. (This is equivalent to the route print command under Windows.)

-s : Displays statistics by protocol. By default, statistics are shown for the TCP, UDP, ICMP, and IP protocols. If the IPv6 protocol for Windows XP is installed, statistics are shown for the TCP over IPv6, UDP over IPv6, ICMPv6, and IPv6 protocols. The -p parameter can be used to specify a set of protocols.

-v : When used in conjunction with -b it will display the sequence of components involved in creating the connection or listening port for all executables.

Interval : Redisplays the selected information every Interval seconds. Press CTRL+C to stop the
redisplay. If this parameter is omitted, netstat prints the selected information only once.

/? : Displays help at the command prompt. (only on Windows)

6. ptrace - process trace
#include <sys/ptrace.h>long ptrace(enum __ptrace_request request, pid_t pid, void*addr, void *data);

The ptrace() system call provides a means by which a parent process may observe and control the execution of another process, and examine and change its core image and registers. It is primarily used to implement breakpoint debugging and system call tracing.

Have you ever wondered how system calls can be intercepted? Have you ever tried fooling the kernel by changing system call arguments? Have you ever wondered how debuggers stop a running process and let you take control of the process?

If you are thinking of using complex kernel programming to accomplish tasks, think again. Linux provides an elegant mechanism to achieve all of these things: the ptrace (Process Trace) system call. ptrace provides a mechanism by which a parent process may observe and control the execution of another process. It can examine and change its core image and registers and is used primarily to implement breakpoint debugging and system call tracing.

Links:
Playing with PTrace Part1 - http://www.linuxjournal.com/article/6100
Playing with PTrace Part2 - http://www.linuxjournal.com/article/6210

7. strace - System Call Trace
Tracing the system calls of a program, we have a very good tool in strace. What is unique about strace is that, when it is run in conjunction with a program, it outputs all the calls made to the kernel by the program.

In many cases, a program may fail because it is unable to open a file or because of insufficient memory. And tracing the output of the program will clearly show the cause of either problem.
The use of strace is quite simple and takes the following form:$ strace

For example, I can run a trace on 'ls' as follows : $ strace ls

And this will output a great amount of data on to the screen. If it is hard to keep track of the scrolling mass of data, then there is an option to write the output of strace to a file instead which is done using the -o option.

For example: $ strace -o strace_ls_output.txt ls
Links
http://linuxhelp.blogspot.com/2006/05/strace-very-powerful-troubleshooting.html
http://www.redhat.com/magazine/010aug05/features/strace/

Virtual Base Class, Multiple Inheritance: Construction and Destruction Order

The construction algorithm now works as follows:

virtual bases have the highest precedence. Depth comes next, and then the order of appearance; leftmost bases are constructed first.

Order of Destructors is just reverse of Construction.

Algorithm:

1. Construct the virtual bases using the previous depth-first left-to-right order of appearance. Since there's only one virtual base B, it's constructed first.

2. Construct the non-virtual bases according to the depth-first left-to-right order of appearance. The deepest base specifier list contains A. Consequently, it's constructed next.

3. Apply the same rule on the next depth level. Consequently, D is constructed.

4. Finally, D2's constructor is called.

Examples:

Example1:

class Base
{
public:
Base() { cout<<"\n Base C'ctor\n"; }
};

class Derived1 : virtual public Base
{
public:
Derived1() { cout<<"\n Derived1 C'ctor\n"; }
};

class Derived2 : virtual public Base
{
public:
Derived2() { cout<<"\n Derived2 C'ctor\n"; }
};

class Derived3 : public Derived1, public Derived2
{
public:
Derived3() { cout<<"\n Derived3 C'ctor\n"; }
};

main()
{
Derived3 d;
}

Output:
Base C'ctor
Derived1 C'ctor
Derived2 C'ctor
Derived3 C'ctor

Example2:

class Base
{
public:
Base() { cout<<"\n Base C'ctor\n"; }
};

class Derived1 : public Base
{
public:
Derived1() { cout<<"\n Derived1 C'ctor\n"; }
};

class Derived2 : public Base
{
public:
Derived2() { cout<<"\n Derived2 C'ctor\n"; }
};

class Derived3 : public Derived1, virtual public Derived2
{
public:
Derived3() { cout<<"\n Derived3 C'ctor\n"; }
};

main()
{
Derived3 d;
}

Output :
Base C'ctor
Derived2 C'ctor
Base C'ctor
Derived1 C'ctor
Derived3 C'ctor

Example3:

class Base
{
public:
Base() { cout<<"\n Base C'ctor\n"; }
};

class Derived1 : public Base
{
public:
Derived1() { cout<<"\n Derived1 C'ctor\n"; }
};

class Derived2 : virtual public Base
{
public:
Derived2() { cout<<"\n Derived2 C'ctor\n"; }
};

class Derived3 : public Derived1, public Derived2
{
public:
Derived3() { cout<<"\n Derived3 C'ctor\n"; }
};

main()
{
Derived3 d;
}

Output:
Base C'ctor
Base C'ctor
Derived1 C'ctor
Derived2 C'ctor
Derived3 C'ctor

Link:
http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=169

Pointer-to-Pointer and Reference-to-Pointer

Why we need Pointer-to-Pointer and Reference-to-Pointer ???

When we use "pass by pointer" to pass a pointer to a function, only a copy of the pointer is passed to the function. We can say "pass by pointer" is passing a pointer using "pass by value." In most cases, this does not present a problem. But, a problem arises when you modify the pointer inside the function. Instead of modifying the variable, it points to it by de-referencing. When you modify the pointer, you are only modifying a copy of the pointer and the original pointer remains unmodified.

Link:
http://www.codeguru.com/cpp/cpp/cpp_mfc/pointers/article.php/c4089/

Private Destructors

Why Private Destructors ???

1. While using Reference Counting Objects

The simple answer – Do n't want anyone to be able to destroy the object.

A reference counting object is, its an object that tracks the number of references to itself, and destroys itself when none of the references point toward it. This is because you don't own the lifetime of the reference. Making it simple, the object may be in use by more than one reference simultaneously. Imagine the situation in which the destructor of this object is public and as one of the refrence is released which innocently calls the destructor which is public and destroys the object. This could result in situations like the object being destroyed and other references still pointing to our dead object. To avoid such situations we make the destructor private and provide alternate function which will be careful enough to invoke the destructor only if the reference count is ZERO.

2. Make sure objects are created only on Heap not Stack

We can achieve this by making destructor private. There by preventing the stack unwinding to happen, which will intern avoid creating variables on stack. Then the user will only be able to create object on heap.

3. When you want to create non inheritable-Final Classes

It could happens that you want your class not to be inherited by any other class i.e., to create a final class. For making a class final all you have to do is make the class’s constructor or destructor private. Since in a class there can be any number of constructors where as it can have only one destructor, it’s easy to keep the single destructor as private and make the class Final.

Links:
http://blogs.msdn.com/larryosterman/archive/2005/07/01/434684.aspx
http://prabhagovind.wordpress.com/2006/12/21/some-thing-about-private-destructors/
http://prashanth-cpp.blogspot.com/2007/01/delete-this.html