Skip to main content

Posts

Showing posts from July, 2005

buffered/unbuffered C++ streams

Conventionally, std::cin, std::cout are buffererd and std::cerr is not buffered. Unbuffered streams are written to device immediately. In general, ofstreams are buffered. You can make a stream unbuffered by invoking setbuf(0,0).

For example,

ofstream of;
of.setbuf(0,0); // makes it unbuffered.

You can force a buffered stream to flush the contents using std::endl. Other interesting thing is to tie an buffered output stream with a buffered input stream. What this means is, whenever you want to accept an input from the input stream, the output stream 'tied' to it is flushed automatically.

For example,
ifstream in; // a buffered input stream.
ofstream out; // a buffered output stream.
and in and out are tied together.

then,
out << "data 1" << "data 2" << ..... << "data N";
// may or may not occur on screen or file.
...
in >> somevar; // out will be flushed before somevar is input.

You do this by invoking:

in.tie(&out);

tie causes …

Unions and Constructors

You can define an union having constructors but a member of class type having constructor is not allowed in union. The reason is obvious: how would the compiler know which destructor to invoke when an object of the union goes out of scope? (for that matter, compiler does not even know which constructor to invoke at the time of creation of an object of such union)

Changing C++ function default arguments

In C++, default arguments of global scope functions can be changed easily.

Typically we use a constant expression as a default argument. C++ supports static variables as well as a constant expression for a default argument. We can also redeclare a function signature in a new scope with a different default value.

Default arguments are implemented as global static variables. Therefore, same effect can be achieved if we assign a differnt value to the static varibale. Following code shows this interesting feature.

******************************************************************************
#include
#include
#include

static int para=200;

void g(int x=para); // default argument is a static variable.
void f(int x=7); // default argument implemented in terms of some static varible.

int main(void)
{
void f(int x=70); // redeclaring function ::f

f(); // prints f70

g(); // prints g200
para=500;
g(); // prints g500

{
void f(int x=700); // redeclaring function f
f();…
My recent experience of programming in C tell me following things:

1. ALWAYS! ALWAYS!! ALWAYS!!! initialize local variables in C.
pointer, integers, chars, user defined structures whatever it is.
Initialize. Uninitialized variables are especially dangerous in
highly recursive programs because somewhere, at some invocation
the variable assumes the 'bad' value and catastrophic results happen
somewhere down in the call stack. You can initialize local
structured data-types such as array and structures using following syntax.

Message m = { 0 } ;
This makes all the elements of the structure equal to zero.
(Message is a type definition for a struct Message_tag)

int i[5] = { 10 } ;
This will make only first element of array i equal to 10, all other will be
zero. Also note that, globals, statics are always by default initialized to
zero. This is not the case with locals. But little more typing can save you
lot of trouble.

2. Containers should hold your …