Reformatted code

Grzegorz Jabłoński
1 parent e02010c3
Showing 84 changed files with 1811 additions and 1934 deletions
examples01-en/01-firstcpp/hellocpp.cpp
examples01-en/02-string/string.cpp
examples01-en/03-vector/vector.cpp
examples01-en/04-qt-1/hello.cpp
examples01-en/05-qt-2/hello.cpp
examples01-en/06-qt-3/hello.cpp
examples01-en/07-stackc/stack.c
examples01-en/07-stackc/stack.h
examples01-en/07-stackc/teststack.c
examples01-en/08-stackcpp/stack.cpp
examples01-en/08-stackcpp/stack.h
examples01-en/08-stackcpp/teststack.cpp
examples01-en/09-funoverload/overload.cpp
examples01-pl/01-kompilacja/hello.c
examples01-pl/02-moduly/hello.c
examples01-pl/02-moduly/witaj.c
examples01-pl/03-cmdline/cmdline.c
examples01-pl/04-malloc/malloc.c
examples01-pl/05-2darray/2darray.c
examples01-pl/06-mymalloc/main.c
@@ -3,5 +3,5 @@ using namespace std;
  
 int main()
 {
-	cout << "Hello from c++\n";
+    cout << "Hello from c++\n";
 }
@@ -4,14 +4,13 @@ using namespace std;
  
 string getword()
 {
-  string s;
-  cin >> s;
-  return s;
+    string s;
+    cin >> s;
+    return s;
 }
  
-
 int main()
-{ 
-        cout << "Podaj slowo" << endl;
-	cout << "Podane slowo to:" << getword() << endl;
+{
+    cout << "Podaj slowo" << endl;
+    cout << "Podane slowo to:" << getword() << endl;
 }
 #include <iostream>
-#include <vector>
 #include <string>
+#include <vector>
 using namespace std;
  
 int main()
 {
-        string word;
-	vector<string> v;
-	while(cin)
-	{
-	  if(cin>>word)
-   	    v.push_back(word);
-	}
-	for(unsigned int i=0;i<v.size();i++)
-	  cout << v[i]<<" ";
-	cout << endl;
+    string word;
+    vector<string> v;
+    while (cin) {
+        if (cin >> word)
+            v.push_back(word);
+    }
+    for (unsigned int i = 0; i < v.size(); i++)
+        cout << v[i] << " ";
+    cout << endl;
 }
 #include <QApplication>
 #include <QPushButton>
  
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
     QApplication app(argc, argv);
  
 #include <QApplication>
 #include <QPushButton>
  
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
     QApplication app(argc, argv);
  
     QPushButton hello("Hello world!");
     hello.resize(100, 30);
     hello.setFont(QFont("Arial", 18, QFont::Bold));
-    hello.setGeometry(400, 200 , 180, 40);
+    hello.setGeometry(400, 200, 180, 40);
  
     hello.show();
     return app.exec();
 #include <QApplication>
-#include <QPushButton>
 #include <QDial>
+#include <QPushButton>
  
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
     QApplication app(argc, argv);
  
     QPushButton hello("Hello world!");
     hello.resize(100, 30);
     hello.setFont(QFont("Arial", 18, QFont::Bold));
-    hello.setGeometry(400, 200 , 180, 40);
+    hello.setGeometry(400, 200, 180, 40);
  
     QDial dial;
     dial.show();
+#include "stack.h"
 #include <assert.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include "stack.h"
+#include <stdlib.h>
  
 void init(struct stack_handle* s)
 {
-	s->top=0;
+    s->top = 0;
 }
  
-void finalize(struct stack_handle* s)
-{
-}
+void finalize(struct stack_handle* s) {}
  
 void clear(struct stack_handle* s)
 {
-	s->top=0;
+    s->top = 0;
 }
  
-void push(struct stack_handle* s,int a)
+void push(struct stack_handle* s, int a)
 {
-        assert(s->top<STACKSIZE);
-	s->data[s->top++]=a;
+    assert(s->top < STACKSIZE);
+    s->data[s->top++] = a;
 }
  
 int pop(struct stack_handle* s)
 {
-	assert(s->top>0);
-	return s->data[--s->top];
+    assert(s->top > 0);
+    return s->data[--s->top];
 }
-
 #define STACKSIZE 20
  
-struct stack_handle
-{
-int top; /* index of first free slot on stack */
-int data[STACKSIZE];
+struct stack_handle {
+    int top; /* index of first free slot on stack */
+    int data[STACKSIZE];
 };
  
-void push(struct stack_handle* s,int a);
+void push(struct stack_handle* s, int a);
 int pop(struct stack_handle* s);
 void clear(struct stack_handle* s);
 void init(struct stack_handle* s);
 void finalize(struct stack_handle* s);
-
-#include <stdio.h>
 #include "stack.h"
+#include <stdio.h>
  
 int main()
 {
-	struct stack_handle s1;
-	struct stack_handle s2;
-	init(&s1);
-	init(&s2);
-	push(&s1,1);
-	push(&s1,2);
-	push(&s1,3);
-	push(&s2,5);
-	push(&s2,6);
-	printf("%d %d\n",pop(&s1),pop(&s2));
-	printf("%d\n",pop(&s1));
-	finalize(&s1);
-	finalize(&s2);
-	return 0;
+    struct stack_handle s1;
+    struct stack_handle s2;
+    init(&s1);
+    init(&s2);
+    push(&s1, 1);
+    push(&s1, 2);
+    push(&s1, 3);
+    push(&s2, 5);
+    push(&s2, 6);
+    printf("%d %d\n", pop(&s1), pop(&s2));
+    printf("%d\n", pop(&s1));
+    finalize(&s1);
+    finalize(&s2);
+    return 0;
 }
-#include <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include "stack.h"
+#include <assert.h>
 #include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
 using namespace std;
  
 stack::stack()
 {
-	this->top=0;
-	cout << "stack::stack() called\n";
-	
+    this->top = 0;
+    cout << "stack::stack() called\n";
 }
  
 stack::~stack()
 {
-	cout << "stack::~stack() called\n";
+    cout << "stack::~stack() called\n";
 }
  
 void stack::clear()
 {
-	this->top=0;
+    this->top = 0;
 }
  
 void stack::push(int a)
 {
-	assert(this->top<STACKSIZE);
-	this->data[this->top++]=a;
+    assert(this->top < STACKSIZE);
+    this->data[this->top++] = a;
 }
  
 int stack::pop()
 {
-	assert(this->top>0);
-	return this->data[--this->top];
+    assert(this->top > 0);
+    return this->data[--this->top];
 }
-
 #define STACKSIZE 20
  
-class stack
-{
-public:
-void push(int a);
-int pop();
-void clear();
-stack();
-~stack();
-private:
-int top;
-int data[STACKSIZE];
-};
+class stack {
+  public:
+    void push(int a);
+    int pop();
+    void clear();
+    stack();
+    ~stack();
  
+  private:
+    int top;
+    int data[STACKSIZE];
+};
-#include <stdio.h>
 #include "stack.h"
+#include <stdio.h>
  
 int main()
 {
-	stack s1;
-	stack s2;
-	s1.push(1);
-	s1.push(2);
-	s1.push(3);
-	s2.push(5);
-	s2.push(6);
-	{
-	 stack s3;
-	}
-	printf("%d %d\n",s1.pop(),s2.pop());
-	printf("%d\n",s1.pop());
-	return 0;
+    stack s1;
+    stack s2;
+    s1.push(1);
+    s1.push(2);
+    s1.push(3);
+    s2.push(5);
+    s2.push(6);
+    {
+        stack s3;
+    }
+    printf("%d %d\n", s1.pop(), s2.pop());
+    printf("%d\n", s1.pop());
+    return 0;
 }
@@ -3,16 +3,16 @@ using namespace std;
  
 void fun(char c)
 {
-	cout<<"fun(char) called"<<endl;
+    cout << "fun(char) called" << endl;
 }
  
 void fun(int c)
 {
-	cout <<"fun(int) called"<<endl;
+    cout << "fun(int) called" << endl;
 }
  
 int main()
 {
-	fun(10);
-	fun('0');
+    fun(10);
+    fun('0');
 }
@@ -2,6 +2,6 @@
  
 int main()
 {
-  printf("Hello, world\n");
-  return 0;
+    printf("Hello, world\n");
+    return 0;
 }
-#include <stdio.h>
 #include "witaj.h"
+#include <stdio.h>
  
 int main()
 {
-  witaj();
-  return 0;
+    witaj();
+    return 0;
 }
-#include <stdio.h>
-#include <math.h>
 #include "witaj.h"
+#include <math.h>
+#include <stdio.h>
  
 void witaj(void)
 {
-  printf ("Hello user %g\n",sqrt(16.0));
+    printf("Hello user %g\n", sqrt(16.0));
 }
@@ -2,10 +2,10 @@
  
 int main(int argc, char** argv)
 {
-int i;
-printf("argc==%d\n",argc);
-for(i=0;i<argc;i++)
-  printf("%s ",argv[i]);
-printf("\n");
-return 0;
+    int i;
+    printf("argc==%d\n", argc);
+    for (i = 0; i < argc; i++)
+        printf("%s ", argv[i]);
+    printf("\n");
+    return 0;
 }
 #include <stdio.h>
 #include <stdlib.h>
  
-int
-main ()
+int main()
 {
-  double *a = NULL;
-  int n;
-  int i;
-  FILE *infile = fopen ("ala", "r");
-  if (fscanf (infile, "%d\n", &n) != 1) abort();
-  a = (double *) malloc (n * sizeof (double));
-  if(a==NULL) abort();
-  for (i = 0; i < n; i++)
-    if (1 != fscanf (infile, "%lf ", /*a+i */ &(a[i]))) abort();
-  for (i = 0; i < n; i++)
-    printf ("%f ", a[i]);
-  printf("\n");
-  free (a);
-  fclose (infile);
-  return 0;
+    double* a = NULL;
+    int n;
+    int i;
+    FILE* infile = fopen("ala", "r");
+    if (fscanf(infile, "%d\n", &n) != 1)
+        abort();
+    a = (double*)malloc(n * sizeof(double));
+    if (a == NULL)
+        abort();
+    for (i = 0; i < n; i++)
+        if (1 != fscanf(infile, "%lf ", /*a+i */ &(a[i])))
+            abort();
+    for (i = 0; i < n; i++)
+        printf("%f ", a[i]);
+    printf("\n");
+    free(a);
+    fclose(infile);
+    return 0;
 }
 #include <stdio.h>
 #include <stdlib.h>
  
-int
-main ()
+int main()
 {
-  double **a = NULL;
-  double **b = NULL;
-  int rows = 3;
-  int columns = 5;
-  int i;
-  a = (double **) malloc (rows * sizeof (double *));
-  for (i = 0; i < rows; i++)
-    a[i] = (double *) malloc (columns * sizeof (double));
-  b = (double **) malloc (rows * sizeof (double *));
-  b[0] = (double *) malloc (rows * columns * sizeof (double));
-  for (i = 1; i < rows; i++)
-    b[i] = b[i-1] + columns;
-  /* use a and b */
-  for (i = 0; i < rows; i++)
-    free (a[i]);
-  free (a);
-  free (b[0]);
-  free (b);
-  return 0;
+    double** a = NULL;
+    double** b = NULL;
+    int rows = 3;
+    int columns = 5;
+    int i;
+    a = (double**)malloc(rows * sizeof(double*));
+    for (i = 0; i < rows; i++)
+        a[i] = (double*)malloc(columns * sizeof(double));
+    b = (double**)malloc(rows * sizeof(double*));
+    b[0] = (double*)malloc(rows * columns * sizeof(double));
+    for (i = 1; i < rows; i++)
+        b[i] = b[i - 1] + columns;
+    /* use a and b */
+    for (i = 0; i < rows; i++)
+        free(a[i]);
+    free(a);
+    free(b[0]);
+    free(b);
+    return 0;
 }
-#include <assert.h>
 #include "mymalloc.h"
+#include <assert.h>
  
 int main()
 {
-void* p1;
-void* p2;
-void* p3;
-void* p4;
-void* p5;
+    void* p1;
+    void* p2;
+    void* p3;
+    void* p4;
+    void* p5;
  
-if(!mymalloc_init(10000000)) abort();
-mymalloc_dump();
-p1=mymalloc(100);
-mymalloc_dump();
-p2=mymalloc(200);
-mymalloc_dump();
-p3=mymalloc(300);
-mymalloc_dump();
-myfree(p2);
-mymalloc_dump();
-p2=mymalloc(150);
-mymalloc_dump();
-p2=myrealloc(p2,170);
-mymalloc_dump();
-p2=myrealloc(p2,300);
-mymalloc_dump();
-p4=mymalloc(10000);
-mymalloc_dump();
-p5=mymalloc(50000);
-mymalloc_dump();
-myfree(p4);
-mymalloc_dump();
-p4=mymalloc(7000);
-mymalloc_dump();
-myfree(p2);
-mymalloc_dump();
-myfree(p1);
-mymalloc_dump();
-myfree(p3);
-mymalloc_dump();
-myfree(p4);
-mymalloc_dump();
-myfree(p5);
-mymalloc_dump();
-return 0;
+    if (!mymalloc_init(10000000))
+        abort();
+    mymalloc_dump();
+    p1 = mymalloc(100);
+    mymalloc_dump();
+    p2 = mymalloc(200);
+    mymalloc_dump();
+    p3 = mymalloc(300);
+    mymalloc_dump();
+    myfree(p2);
+    mymalloc_dump();
+    p2 = mymalloc(150);
+    mymalloc_dump();
+    p2 = myrealloc(p2, 170);
+    mymalloc_dump();
+    p2 = myrealloc(p2, 300);
+    mymalloc_dump();
+    p4 = mymalloc(10000);
+    mymalloc_dump();
+    p5 = mymalloc(50000);
+    mymalloc_dump();
+    myfree(p4);
+    mymalloc_dump();
+    p4 = mymalloc(7000);
+    mymalloc_dump();
+    myfree(p2);
+    mymalloc_dump();
+    myfree(p1);
+    mymalloc_dump();
+    myfree(p3);
+    mymalloc_dump();
+    myfree(p4);
+    mymalloc_dump();
+    myfree(p5);
+    mymalloc_dump();
+    return 0;
 }
-#include <unistd.h>
+#include "mymalloc.h"
 #include <assert.h>
 #include <stdio.h>
 #include <string.h>
-#include "mymalloc.h"
+#include <unistd.h>
  
-typedef struct _blkdata
-{
-  unsigned long size;		/* rozmiar bloku wlaczajac naglowek */
-  unsigned int flags;
-}
-blkdata;
+typedef struct _blkdata {
+    unsigned long size; /* rozmiar bloku wlaczajac naglowek */
+    unsigned int flags;
+} blkdata;
 #define MM_OCCUPIED 1
 #define MM_LAST 2
  
-static void *begin;
+static void* begin;
  
-int
-mymalloc_init (unsigned long size)
+int mymalloc_init(unsigned long size)
 {
-  blkdata *b;
-  assert (size > 0);
-  begin = sbrk (size);
-  if (!begin)
-    return 0;
-  b = (blkdata *) begin;
-  b->size = size;
-  b->flags = MM_LAST;
-  return 1;
+    blkdata* b;
+    assert(size > 0);
+    begin = sbrk(size);
+    if (!begin)
+        return 0;
+    b = (blkdata*)begin;
+    b->size = size;
+    b->flags = MM_LAST;
+    return 1;
 };
  
-void *
-mymalloc (unsigned long size)
+void* mymalloc(unsigned long size)
 {
-  blkdata *b = (blkdata *) begin;
-  printf ("Request to allocate %lu bytes\n", size);
-  while (1)
-    {
-      if ((b->size > size + sizeof (blkdata)) && !(b->flags & MM_OCCUPIED))
-	{
-	  unsigned long after = b->size - size - sizeof (blkdata);
-	  if (after > sizeof (blkdata))
-	    {
-	      blkdata *na =
-		(blkdata *) ((void *) b + size + sizeof (blkdata));
-	      na->flags = 0;
-	      if (b->flags & MM_LAST)
-		na->flags |= MM_LAST;
-	      na->size = after;
-	      b->size = size + sizeof (blkdata);
-	      b->flags = MM_OCCUPIED;
-	      return ((void *) b) + sizeof (blkdata);
-	    }
-	  else			/* wez caly blok */
-	    {
-	      b->flags |= MM_OCCUPIED;
-	      return ((void *) b) + sizeof (blkdata);
-	    }
-	};
-      if (b->flags & MM_LAST)
-	break;
-      b = (blkdata *) ((void *) b + b->size);
+    blkdata* b = (blkdata*)begin;
+    printf("Request to allocate %lu bytes\n", size);
+    while (1) {
+        if ((b->size > size + sizeof(blkdata)) && !(b->flags & MM_OCCUPIED)) {
+            unsigned long after = b->size - size - sizeof(blkdata);
+            if (after > sizeof(blkdata)) {
+                blkdata* na = (blkdata*)((void*)b + size + sizeof(blkdata));
+                na->flags = 0;
+                if (b->flags & MM_LAST)
+                    na->flags |= MM_LAST;
+                na->size = after;
+                b->size = size + sizeof(blkdata);
+                b->flags = MM_OCCUPIED;
+                return ((void*)b) + sizeof(blkdata);
+            }
+            else /* wez caly blok */
+            {
+                b->flags |= MM_OCCUPIED;
+                return ((void*)b) + sizeof(blkdata);
+            }
+        };
+        if (b->flags & MM_LAST)
+            break;
+        b = (blkdata*)((void*)b + b->size);
     };
-  return NULL;
+    return NULL;
 }
  
-void
-myfree (void *ptr)
+void myfree(void* ptr)
 {
-  blkdata *b;
-  blkdata *nextb = NULL;
-  blkdata *prevb = NULL;
-  if (ptr == NULL)
-    return;
-  b = (blkdata *) (ptr - sizeof (blkdata));
-  printf ("Request to free %lu bytes at the address %p\n", b->size - sizeof (blkdata), b);
-  if ((void *) b != begin)
-    {
-/* znajdz poprzedni blok */
-      prevb = (blkdata *) begin;
-      while (1)
-	{
-	  blkdata *next;
-	  assert (!(prevb->flags & MM_LAST));
-	  next = (blkdata *) ((void *) prevb + prevb->size);
-	  if (next == b)
-	    break;
-	  prevb = next;
-	};
+    blkdata* b;
+    blkdata* nextb = NULL;
+    blkdata* prevb = NULL;
+    if (ptr == NULL)
+        return;
+    b = (blkdata*)(ptr - sizeof(blkdata));
+    printf("Request to free %lu bytes at the address %p\n",
+           b->size - sizeof(blkdata), b);
+    if ((void*)b != begin) {
+        /* znajdz poprzedni blok */
+        prevb = (blkdata*)begin;
+        while (1) {
+            blkdata* next;
+            assert(!(prevb->flags & MM_LAST));
+            next = (blkdata*)((void*)prevb + prevb->size);
+            if (next == b)
+                break;
+            prevb = next;
+        };
     };
-/* znajdz nastepny blok */
-  if (!(b->flags & MM_LAST))
-    nextb = (blkdata *) ((void *) b + b->size);
-/* zaznacz blok jako wolny */
-  b->flags &= ~MM_OCCUPIED;
-/* skonsoliduj z nastepnym */
-  if (nextb && !(nextb->flags & MM_OCCUPIED))
-    {
-      if (nextb->flags & MM_LAST)
-	b->flags = MM_LAST;
-      b->size += nextb->size;
+    /* znajdz nastepny blok */
+    if (!(b->flags & MM_LAST))
+        nextb = (blkdata*)((void*)b + b->size);
+    /* zaznacz blok jako wolny */
+    b->flags &= ~MM_OCCUPIED;
+    /* skonsoliduj z nastepnym */
+    if (nextb && !(nextb->flags & MM_OCCUPIED)) {
+        if (nextb->flags & MM_LAST)
+            b->flags = MM_LAST;
+        b->size += nextb->size;
     }
-/* skonsoliduj z poprzednim */
-  if (prevb && !(prevb->flags & MM_OCCUPIED))
-    {
-      if (b->flags & MM_LAST)
-	prevb->flags |= MM_LAST;
-      prevb->size += b->size;
+    /* skonsoliduj z poprzednim */
+    if (prevb && !(prevb->flags & MM_OCCUPIED)) {
+        if (b->flags & MM_LAST)
+            prevb->flags |= MM_LAST;
+        prevb->size += b->size;
     };
 }
  
-static void *
-copyrealloc (void *ptr, unsigned long size, unsigned long oldsize)
+static void* copyrealloc(void* ptr, unsigned long size, unsigned long oldsize)
 {
-  void *blk = mymalloc (size);
-  if (blk == NULL)
-    return NULL;
-  memcpy (blk, ptr, oldsize);
-  myfree (ptr);
-  return blk;
+    void* blk = mymalloc(size);
+    if (blk == NULL)
+        return NULL;
+    memcpy(blk, ptr, oldsize);
+    myfree(ptr);
+    return blk;
 }
  
-void *
-myrealloc (void *ptr, unsigned long size)
+void* myrealloc(void* ptr, unsigned long size)
 {
-  blkdata *b;
-  if (ptr == NULL)
-    return mymalloc (size);
-  b = (blkdata *) (ptr - sizeof (blkdata));
-  printf ("Request to reallocate %lu bytes to %lu bytes, old address=%p\n",
-	  b->size - sizeof (blkdata), size, b);
-  if (size == 0)
-    {
-      myfree (ptr);
-      return NULL;
+    blkdata* b;
+    if (ptr == NULL)
+        return mymalloc(size);
+    b = (blkdata*)(ptr - sizeof(blkdata));
+    printf("Request to reallocate %lu bytes to %lu bytes, old address=%p\n",
+           b->size - sizeof(blkdata), size, b);
+    if (size == 0) {
+        myfree(ptr);
+        return NULL;
     };
-  if (size <= b->size - sizeof (blkdata))	/* zmniejszenie bloku */
+    if (size <= b->size - sizeof(blkdata)) /* zmniejszenie bloku */
     {
-      unsigned long after = b->size - size - sizeof (blkdata);
-      blkdata *nextb = NULL;
-      if (!(b->flags & MM_LAST))
-	nextb = (blkdata *) ((void *) b + b->size);
-      blkdata *na = ((void *) b) + size + sizeof (blkdata);
-      if (nextb && !(nextb->flags & MM_OCCUPIED))
-	/* skonsoliduj z nastepnym */
-	{
-	  unsigned int flags = nextb->flags;
-	  unsigned long size = after + nextb->size;
-	  na->flags = flags;
-	  na->size = size;
-	  b->size = size + sizeof (blkdata);
-	}
-      else if (after > sizeof (blkdata))
-	{
-	  na->flags = 0;
-	  if (b->flags & MM_LAST)
-	    na->flags |= MM_LAST;
-	  na->size = after;
-	  b->size = size + sizeof (blkdata);
-	  b->flags = MM_OCCUPIED;
-	}
-      return ptr;
+        unsigned long after = b->size - size - sizeof(blkdata);
+        blkdata* nextb = NULL;
+        if (!(b->flags & MM_LAST))
+            nextb = (blkdata*)((void*)b + b->size);
+        blkdata* na = ((void*)b) + size + sizeof(blkdata);
+        if (nextb && !(nextb->flags & MM_OCCUPIED))
+        /* skonsoliduj z nastepnym */
+        {
+            unsigned int flags = nextb->flags;
+            unsigned long size = after + nextb->size;
+            na->flags = flags;
+            na->size = size;
+            b->size = size + sizeof(blkdata);
+        }
+        else if (after > sizeof(blkdata)) {
+            na->flags = 0;
+            if (b->flags & MM_LAST)
+                na->flags |= MM_LAST;
+            na->size = after;
+            b->size = size + sizeof(blkdata);
+            b->flags = MM_OCCUPIED;
+        }
+        return ptr;
     }
-  else				/* zwiekszenie bloku */
+    else /* zwiekszenie bloku */
     {
-      blkdata *next = (blkdata *) ((void *) b + b->size);
-      if (!(b->flags & MM_LAST) && !(next->flags & MM_OCCUPIED))
-	{
-	  unsigned long totalsize = b->size + next->size;
-	  unsigned long after = totalsize - size - sizeof (blkdata);
-	  if (size + sizeof (blkdata) > totalsize)	/* brak miejsca w nastepnym bloku */
-	    return copyrealloc (ptr, size, b->size - sizeof (blkdata));
-	  if (next->flags & MM_LAST)
-	    b->flags |= MM_LAST;
-	  if (after > sizeof (blkdata))
-	    {
-	      blkdata *na =
-		(blkdata *) ((void *) b + size + sizeof (blkdata));
-	      na->flags = 0;
-	      if (b->flags & MM_LAST)
-		na->flags |= MM_LAST;
-	      na->size = after;
-	      b->size = size + sizeof (blkdata);
-	      b->flags = MM_OCCUPIED;
-	    }
-	  else
-	    b->size += next->size;
-	  return ptr;
-	}
-      else			/* nastepny zajety albo biezacy ostatni */
-	return copyrealloc (ptr, size, b->size - sizeof (blkdata));
+        blkdata* next = (blkdata*)((void*)b + b->size);
+        if (!(b->flags & MM_LAST) && !(next->flags & MM_OCCUPIED)) {
+            unsigned long totalsize = b->size + next->size;
+            unsigned long after = totalsize - size - sizeof(blkdata);
+            if (size + sizeof(blkdata) >
+                totalsize) /* brak miejsca w nastepnym bloku */
+                return copyrealloc(ptr, size, b->size - sizeof(blkdata));
+            if (next->flags & MM_LAST)
+                b->flags |= MM_LAST;
+            if (after > sizeof(blkdata)) {
+                blkdata* na = (blkdata*)((void*)b + size + sizeof(blkdata));
+                na->flags = 0;
+                if (b->flags & MM_LAST)
+                    na->flags |= MM_LAST;
+                na->size = after;
+                b->size = size + sizeof(blkdata);
+                b->flags = MM_OCCUPIED;
+            }
+            else
+                b->size += next->size;
+            return ptr;
+        }
+        else /* nastepny zajety albo biezacy ostatni */
+            return copyrealloc(ptr, size, b->size - sizeof(blkdata));
     }
 }
  
-void
-mymalloc_dump ()
+void mymalloc_dump()
 {
-  blkdata *b = (blkdata *) begin;
-  unsigned long totalsize = 0;
-  printf ("Mymalloc block list dump\n");
-  while (1)
-    {
-      printf ("Block at the address %p flags %c%c size %lu\n", b,
-	      (b->flags & MM_OCCUPIED) ? 'O' : 'F',
-	      (b->flags & MM_LAST) ? 'L' : ' ', b->size);
-      totalsize += b->size;
-      if (b->flags & MM_LAST)
-	break;
-      b = (blkdata *) ((void *) b + b->size);
+    blkdata* b = (blkdata*)begin;
+    unsigned long totalsize = 0;
+    printf("Mymalloc block list dump\n");
+    while (1) {
+        printf("Block at the address %p flags %c%c size %lu\n", b,
+               (b->flags & MM_OCCUPIED) ? 'O' : 'F',
+               (b->flags & MM_LAST) ? 'L' : ' ', b->size);
+        totalsize += b->size;
+        if (b->flags & MM_LAST)
+            break;
+        b = (blkdata*)((void*)b + b->size);
     };
-  printf ("Total size:%lu\n", totalsize);
+    printf("Total size:%lu\n", totalsize);
 }
@@ -3,4 +3,3 @@ void* mymalloc(unsigned long size);
 void myfree(void* ptr);
 void* myrealloc(void* ptr, unsigned long size);
 void mymalloc_dump(void);
-
@@ -2,8 +2,7 @@
  
 int main()
 {
-  int* a;
-  *a=10;
-  return 0;
+    int* a;
+    *a = 10;
+    return 0;
 }
-
@@ -2,8 +2,8 @@
  
 int main()
 {
-  int b;
-  int* a=&b;
-  *a=10;
-  return 0;
+    int b;
+    int* a = &b;
+    *a = 10;
+    return 0;
 }
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
  
 char* itoa(int a)
 {
-  char buf[20];
-  snprintf(buf,20,"%d", a);
-  return buf;
+    char buf[20];
+    snprintf(buf, 20, "%d", a);
+    return buf;
 }
  
 int main()
 {
-  printf("%s %s\n",itoa(17), itoa(15));
-  return 0;
+    printf("%s %s\n", itoa(17), itoa(15));
+    return 0;
 }
-
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
  
 char* itoa(int a)
 {
-  static char buf[20];
-  snprintf(buf,20,"%d", a);
-  return buf;
+    static char buf[20];
+    snprintf(buf, 20, "%d", a);
+    return buf;
 }
  
 int main()
 {
-  printf("%s %s\n",itoa(17), itoa(15));
-  return 0;
+    printf("%s %s\n", itoa(17), itoa(15));
+    return 0;
 }
-
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
  
 char* itoa(int a)
 {
-  char * buf = (char*)malloc(20);
-  snprintf(buf,20,"%d", a);
-  return buf;
+    char* buf = (char*)malloc(20);
+    snprintf(buf, 20, "%d", a);
+    return buf;
 }
  
 int main()
 {
-  char *w1, *w2;
-  printf("%s %s\n",w1=itoa(17), w2=itoa(15));
-  free(w1);
-  free(w2);
-  return 0;
+    char *w1, *w2;
+    printf("%s %s\n", w1 = itoa(17), w2 = itoa(15));
+    free(w1);
+    free(w2);
+    return 0;
 }
-
@@ -2,8 +2,7 @@
  
 int main()
 {
-	char* a=(char*)malloc(10);
-	a[10]='c';
-	return 0;
+    char* a = (char*)malloc(10);
+    a[10] = 'c';
+    return 0;
 }
-
@@ -2,9 +2,8 @@
  
 int main()
 {
-	char a[10];
-	a[10]='c';
-	free(a);
-	return 0;
+    char a[10];
+    a[10] = 'c';
+    free(a);
+    return 0;
 }
-
@@ -3,5 +3,5 @@ using namespace std;
  
 int main()
 {
-	cout << "Hello from c++\n";
+    cout << "Hello from c++\n";
 }
@@ -4,15 +4,13 @@ using namespace std;
  
 string getword()
 {
-  string s;
-  cin >> s;
-  return s;
+    string s;
+    cin >> s;
+    return s;
 }
  
-
 int main()
-{ 
-        cout << "Podaj slowo" << endl;
-	cout << "Podane slowo to:" << getword() << endl;
+{
+    cout << "Podaj slowo" << endl;
+    cout << "Podane slowo to:" << getword() << endl;
 }
-
 #include <iostream>
-#include <vector>
 #include <string>
+#include <vector>
 using namespace std;
  
 int main()
 {
-        string word;
-	vector<string> v;
-	while(cin)
-	{
-	  if(cin>>word)
-   	    v.push_back(word);
-	}
-	for(unsigned int i=0;i<v.size();i++)
-	  cout << v[i]<<" ";
-	cout << endl;
+    string word;
+    vector<string> v;
+    while (cin) {
+        if (cin >> word)
+            v.push_back(word);
+    }
+    for (unsigned int i = 0; i < v.size(); i++)
+        cout << v[i] << " ";
+    cout << endl;
 }
-
 #include <QApplication>
 #include <QPushButton>
  
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
     QApplication app(argc, argv);
  
 #include <QApplication>
 #include <QPushButton>
  
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
     QApplication app(argc, argv);
  
     QPushButton hello("Hello world!");
     hello.resize(100, 30);
     hello.setFont(QFont("Arial", 18, QFont::Bold));
-    hello.setGeometry(400, 200 , 180, 40);
+    hello.setGeometry(400, 200, 180, 40);
  
     hello.show();
     return app.exec();
 #include <QApplication>
-#include <QPushButton>
 #include <QDial>
+#include <QPushButton>
  
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
     QApplication app(argc, argv);
  
     QPushButton hello("Hello world!");
     hello.resize(100, 30);
     hello.setFont(QFont("Arial", 18, QFont::Bold));
-    hello.setGeometry(400, 200 , 180, 40);
+    hello.setGeometry(400, 200, 180, 40);
  
     QDial dial;
     dial.show();
-#include <assert.h>
 #include "stack.h"
+#include <assert.h>
  
 #define STACKSIZE 20
 static int top; /* pierwsze wolne miejsce na stosie */
@@ -7,27 +7,24 @@ static int dane[STACKSIZE];
  
 void init()
 {
-	top=0;
+    top = 0;
 }
  
-void finalize()
-{
-}
+void finalize() {}
  
 void clear()
 {
-	top=0;
+    top = 0;
 }
  
 void push(int a)
 {
-	assert(top<STACKSIZE);
-	dane[top++]=a;
+    assert(top < STACKSIZE);
+    dane[top++] = a;
 }
  
 int pop()
 {
-	assert(top>0);
-	return dane[--top];
+    assert(top > 0);
+    return dane[--top];
 }
-
-#include <stdio.h>
 #include "stack.h"
+#include <stdio.h>
  
 int main()
 {
-        init();
-	push(1);
-	push(2);
-	push(3);
-	printf("%d %d\n",pop(),pop());
-	printf("%d\n",pop());
-	finalize();
-	return 0;
+    init();
+    push(1);
+    push(2);
+    push(3);
+    printf("%d %d\n", pop(), pop());
+    printf("%d\n", pop());
+    finalize();
+    return 0;
 }
+#include "stack.h"
 #include <assert.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include "stack.h"
+#include <stdlib.h>
  
 static int top; /* pierwsze wolne miejsce na stosie */
-static int *dane;
+static int* dane;
 static int size;
  
 void init()
 {
-	top=0;
-	size=0;
-	dane=0;
+    top = 0;
+    size = 0;
+    dane = 0;
 }
  
 void finalize()
 {
-  free(dane);
+    free(dane);
 }
  
 void clear()
 {
-	top=0;
+    top = 0;
 }
  
 void push(int a)
 {
-	if(top>=size)
-	{
-	  int newsize=(size+1)*2;
-	  int* ndane=(int*)realloc(dane,newsize*sizeof(int));
-	  if(ndane)
-	    dane=ndane;
-	  else
-	  {
-	    free(dane);
-	    abort();
-	  }
-	  fprintf(stderr,"Rozmiar stosu %d -> %d\n",size,newsize);
-	  size=newsize;
-	}
-	dane[top++]=a;
+    if (top >= size) {
+        int newsize = (size + 1) * 2;
+        int* ndane = (int*)realloc(dane, newsize * sizeof(int));
+        if (ndane)
+            dane = ndane;
+        else {
+            free(dane);
+            abort();
+        }
+        fprintf(stderr, "Rozmiar stosu %d -> %d\n", size, newsize);
+        size = newsize;
+    }
+    dane[top++] = a;
 }
  
 int pop()
 {
-	assert(top>0);
-	return dane[--top];
+    assert(top > 0);
+    return dane[--top];
 }
-
-#include <stdio.h>
 #include "stack.h"
+#include <stdio.h>
  
 int main()
 {
-        init();
-	push(1);
-	push(2);
-	push(3);
-	printf("%d %d\n",pop(),pop());
-	printf("%d\n",pop());
-	finalize();
-	return 0;
+    init();
+    push(1);
+    push(2);
+    push(3);
+    printf("%d %d\n", pop(), pop());
+    printf("%d\n", pop());
+    finalize();
+    return 0;
 }
+#include "stack.h"
 #include <assert.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include "stack.h"
+#include <stdlib.h>
  
 #define STACKSIZE 20
  
-struct stack_handle
-{
-int top; /* pierwsze wolne miejsce na stosie */
-int dane[STACKSIZE];
+struct stack_handle {
+    int top; /* pierwsze wolne miejsce na stosie */
+    int dane[STACKSIZE];
 }
  
-
-struct stack_handle* init()
+struct stack_handle*
+init()
 {
-        struct stack_handle* s=(struct stack_handle*)malloc(sizeof(struct stack_handle));
-	s->top=0;
-	return s;
+    struct stack_handle* s =
+        (struct stack_handle*)malloc(sizeof(struct stack_handle));
+    s->top = 0;
+    return s;
 }
  
 void finalize(struct stack_handle* s)
 {
-  free(s);
+    free(s);
 }
  
 void clear(struct stack_handle* s)
 {
-	s->top=0;
+    s->top = 0;
 }
  
-void push(struct stack_handle* s,int a)
+void push(struct stack_handle* s, int a)
 {
-        assert(s->top<STACKSIZE);
-	s->dane[s->top++]=a;
+    assert(s->top < STACKSIZE);
+    s->dane[s->top++] = a;
 }
  
 int pop(struct stack_handle* s)
 {
-	assert(s->top>0);
-	return s->dane[--s->top];
+    assert(s->top > 0);
+    return s->dane[--s->top];
 }
-
 struct stack_handle;
  
-void push(struct stack_handle* s,int a);
+void push(struct stack_handle* s, int a);
 int pop(struct stack_handle* s);
 void clear(struct stack_handle* s);
 struct stack_handle* init(void);
-#include <stdio.h>
 #include "stack.h"
+#include <stdio.h>
  
 int main()
 {
-	struct stack_handle * s1=init();
-	struct stack_handle * s2=init();
-	push(s1,1);
-	push(s1,2);
-	push(s1,3);
-	push(s2,5);
-	push(s2,6);
-	printf("%d %d\n",pop(s1),pop(s2));
-	printf("%d\n",pop(s1));
-	finalize(s1);
-	finalize(s2);
-	return 0;
+    struct stack_handle* s1 = init();
+    struct stack_handle* s2 = init();
+    push(s1, 1);
+    push(s1, 2);
+    push(s1, 3);
+    push(s2, 5);
+    push(s2, 6);
+    printf("%d %d\n", pop(s1), pop(s2));
+    printf("%d\n", pop(s1));
+    finalize(s1);
+    finalize(s2);
+    return 0;
 }
+#include "stack.h"
 #include <assert.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include "stack.h"
+#include <stdlib.h>
  
 void init(struct stack_handle* s)
 {
-	s->top=0;
+    s->top = 0;
 }
  
-void finalize(struct stack_handle* s)
-{
-}
+void finalize(struct stack_handle* s) {}
  
 void clear(struct stack_handle* s)
 {
-	s->top=0;
+    s->top = 0;
 }
  
-void push(struct stack_handle* s,int a)
+void push(struct stack_handle* s, int a)
 {
-        assert(s->top<STACKSIZE);
-	s->dane[s->top++]=a;
+    assert(s->top < STACKSIZE);
+    s->dane[s->top++] = a;
 }
  
 int pop(struct stack_handle* s)
 {
-	assert(s->top>0);
-	return s->dane[--s->top];
+    assert(s->top > 0);
+    return s->dane[--s->top];
 }
-
 #define STACKSIZE 20
  
-struct stack_handle
-{
-int top; /* pierwsze wolne miejsce na stosie */
-int dane[STACKSIZE];
+struct stack_handle {
+    int top; /* pierwsze wolne miejsce na stosie */
+    int dane[STACKSIZE];
 };
  
-void push(struct stack_handle* s,int a);
+void push(struct stack_handle* s, int a);
 int pop(struct stack_handle* s);
 void clear(struct stack_handle* s);
 void init(struct stack_handle* s);
 void finalize(struct stack_handle* s);
-
-#include <stdio.h>
 #include "stack.h"
+#include <stdio.h>
  
 int main()
 {
-	struct stack_handle s1;
-	struct stack_handle s2;
-	init(&s1);
-	init(&s2);
-	push(&s1,1);
-	push(&s1,2);
-	push(&s1,3);
-	push(&s2,5);
-	push(&s2,6);
-	printf("%d %d\n",pop(&s1),pop(&s2));
-	printf("%d\n",pop(&s1));
-	finalize(&s1);
-	finalize(&s2);
-	return 0;
+    struct stack_handle s1;
+    struct stack_handle s2;
+    init(&s1);
+    init(&s2);
+    push(&s1, 1);
+    push(&s1, 2);
+    push(&s1, 3);
+    push(&s2, 5);
+    push(&s2, 6);
+    printf("%d %d\n", pop(&s1), pop(&s2));
+    printf("%d\n", pop(&s1));
+    finalize(&s1);
+    finalize(&s2);
+    return 0;
 }
+#include "stack.h"
 #include <assert.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include "stack.h"
+#include <stdlib.h>
  
 stack::stack()
 {
-	this->top=0;
+    this->top = 0;
 }
  
-stack::~stack()
-{
-}
+stack::~stack() {}
  
 void stack::clear()
 {
-	this->top=0;
+    this->top = 0;
 }
  
 void stack::push(int a)
 {
-	assert(this->top<STACKSIZE);
-	this->dane[this->top++]=a;
+    assert(this->top < STACKSIZE);
+    this->dane[this->top++] = a;
 }
  
 int stack::pop()
 {
-	assert(this->top>0);
-	return this->dane[--this->top];
+    assert(this->top > 0);
+    return this->dane[--this->top];
 }
-
 #define STACKSIZE 20
  
-class stack
-{
-public:
-void push(int a);
-int pop();
-void clear();
-stack();
-~stack();
-private:
-int top;
-int dane[STACKSIZE];
-};
+class stack {
+  public:
+    void push(int a);
+    int pop();
+    void clear();
+    stack();
+    ~stack();
  
+  private:
+    int top;
+    int dane[STACKSIZE];
+};
-#include <stdio.h>
 #include "stack.h"
+#include <stdio.h>
  
 int main()
 {
-	stack s1;
-	stack s2;
-	s1.push(1);
-	s1.push(2);
-	s1.push(3);
-	s2.push(5);
-	s2.push(6);
-	printf("%d %d\n",s1.pop(),s2.pop());
-	printf("%d\n",s1.pop());
-	return 0;
+    stack s1;
+    stack s2;
+    s1.push(1);
+    s1.push(2);
+    s1.push(3);
+    s2.push(5);
+    s2.push(6);
+    printf("%d %d\n", s1.pop(), s2.pop());
+    printf("%d\n", s1.pop());
+    return 0;
 }
 #include "DateType.h"
  
 /** Constructors **/
-DateType::DateType() {
-  Day = 1;
-  Month = 1;
-  Year = 1;
+DateType::DateType()
+{
+    Day = 1;
+    Month = 1;
+    Year = 1;
 }
-DateType::DateType(int newMonth, int newDay, int newYear) {
-  Day = newDay;
-  Month = newMonth;
-  Year = newYear;
+DateType::DateType(int newMonth, int newDay, int newYear)
+{
+    Day = newDay;
+    Month = newMonth;
+    Year = newYear;
 }
 // returns Year
-int DateType::GetYear() const { return Year; }
+int DateType::GetYear() const
+{
+    return Year;
+}
 // returns Month
-int DateType::GetMonth() const { return Month; }
+int DateType::GetMonth() const
+{
+    return Month;
+}
 // returns Day
-int DateType::GetDay() const { return Day; }
+int DateType::GetDay() const
+{
+    return Day;
+}
  
-RelationType DateType::ComparedTo(DateType otherDate) {
-  if (Year < otherDate.Year)
-    return Precedes;
-  if (Year > otherDate.Year)
-    return Follows;
-  if (Month < otherDate.Month)
-    return Precedes;
-  if (Month > otherDate.Month)
-    return Follows;
-  if (Day < otherDate.Day)
-    return Precedes;
-  if (Day > otherDate.Day)
-    return Follows;
-  return Same;
+RelationType DateType::ComparedTo(DateType otherDate)
+{
+    if (Year < otherDate.Year)
+        return Precedes;
+    if (Year > otherDate.Year)
+        return Follows;
+    if (Month < otherDate.Month)
+        return Precedes;
+    if (Month > otherDate.Month)
+        return Follows;
+    if (Day < otherDate.Day)
+        return Precedes;
+    if (Day > otherDate.Day)
+        return Follows;
+    return Same;
 }
 enum RelationType { Precedes, Same, Follows };
  
 class DateType {
-public:
-  // constructor
-  DateType();
-  DateType(int newMonth, int newDay, int newYear);
-  // accessor methods (get methods)
-  int GetYear() const;  // returns Year
-  int GetMonth() const; // returns Month
-  int GetDay() const;   // returns Day
-  RelationType ComparedTo(DateType dateA);
+  public:
+    // constructor
+    DateType();
+    DateType(int newMonth, int newDay, int newYear);
+    // accessor methods (get methods)
+    int GetYear() const;  // returns Year
+    int GetMonth() const; // returns Month
+    int GetDay() const;   // returns Day
+    RelationType ComparedTo(DateType dateA);
  
-private:
-  int Year;
-  int Month;
-  int Day;
+  private:
+    int Year;
+    int Month;
+    int Day;
 };
 \ No newline at end of file
@@ -3,78 +3,82 @@
 #include <iostream>
 using namespace std;
  
-void PrintMonth(int Month, ostream &Out) {
-  switch (Month) {
-  case 1:
-    Out << "January";
-    return;
-  case 2:
-    Out << "February";
-    return;
-  case 3:
-    Out << "March";
-    return;
-  case 4:
-    Out << "April";
-    return;
-  case 5:
-    Out << "May";
-    return;
-  case 6:
-    Out << "June";
-    return;
-  case 7:
-    Out << "July";
-    return;
-  case 8:
-    Out << "August";
-    return;
-  case 9:
-    Out << "September";
-    return;
-  case 10:
-    Out << "October";
-    return;
-  case 11:
-    Out << "November";
-    return;
-  case 12:
-    Out << "December";
-    return;
-  default:
-    Out << "Juvember";
-  }
+void PrintMonth(int Month, ostream& Out)
+{
+    switch (Month) {
+    case 1:
+        Out << "January";
+        return;
+    case 2:
+        Out << "February";
+        return;
+    case 3:
+        Out << "March";
+        return;
+    case 4:
+        Out << "April";
+        return;
+    case 5:
+        Out << "May";
+        return;
+    case 6:
+        Out << "June";
+        return;
+    case 7:
+        Out << "July";
+        return;
+    case 8:
+        Out << "August";
+        return;
+    case 9:
+        Out << "September";
+        return;
+    case 10:
+        Out << "October";
+        return;
+    case 11:
+        Out << "November";
+        return;
+    case 12:
+        Out << "December";
+        return;
+    default:
+        Out << "Juvember";
+    }
 }
  
-void PrintDate(DateType aDate, ostream &Out) {
-  PrintMonth(aDate.GetMonth(), Out);
-  Out << ' ' << aDate.GetDay() << ", " << setw(4) << aDate.GetYear() << endl;
+void PrintDate(DateType aDate, ostream& Out)
+{
+    PrintMonth(aDate.GetMonth(), Out);
+    Out << ' ' << aDate.GetDay() << ", " << setw(4) << aDate.GetYear() << endl;
 }
  
-RelationType ComparedTo(DateType dateA, DateType dateB) {
-  if (dateA.GetYear() < dateB.GetYear())
-    return Precedes;
-  if (dateA.GetYear() > dateB.GetYear())
-    return Follows;
-  if (dateA.GetMonth() < dateB.GetMonth())
-    return Precedes;
-  if (dateA.GetMonth() > dateB.GetMonth())
-    return Follows;
-  if (dateA.GetDay() < dateB.GetDay())
-    return Precedes;
-  if (dateA.GetDay() > dateB.GetDay())
-    return Follows;
-  return Same;
+RelationType ComparedTo(DateType dateA, DateType dateB)
+{
+    if (dateA.GetYear() < dateB.GetYear())
+        return Precedes;
+    if (dateA.GetYear() > dateB.GetYear())
+        return Follows;
+    if (dateA.GetMonth() < dateB.GetMonth())
+        return Precedes;
+    if (dateA.GetMonth() > dateB.GetMonth())
+        return Follows;
+    if (dateA.GetDay() < dateB.GetDay())
+        return Precedes;
+    if (dateA.GetDay() > dateB.GetDay())
+        return Follows;
+    return Same;
 }
  
-int main() {
-  DateType Tomorrow(1, 18, 2002), AnotherDay(10, 12, 1885);
-  if (ComparedTo(Tomorrow, AnotherDay) == Same) {
-    cout << "what do you think?" << endl;
-  }
+int main()
+{
+    DateType Tomorrow(1, 18, 2002), AnotherDay(10, 12, 1885);
+    if (ComparedTo(Tomorrow, AnotherDay) == Same) {
+        cout << "what do you think?" << endl;
+    }
  
-  if (Tomorrow.ComparedTo(AnotherDay) == Same)
-    cout << "Think about it, Scarlett!" << endl;
+    if (Tomorrow.ComparedTo(AnotherDay) == Same)
+        cout << "Think about it, Scarlett!" << endl;
  
-  PrintDate(Tomorrow, cout);
+    PrintDate(Tomorrow, cout);
 }
 #include <stdio.h>
  
-int *
-f1 (int *a, const int *b)
+int* f1(int* a, const int* b)
 {
-  *a += *b;
-  return a;
+    *a += *b;
+    return a;
 }
  
-int *
-f2 (int *a, const int *b)
+int* f2(int* a, const int* b)
 {
-  *a -= *b;
-  return a;
+    *a -= *b;
+    return a;
 }
  
-int *(*fun (int s)) (int *, const int *)
+int* (*fun(int s))(int*, const int*)
 {
-  if (s == 1)
-    return f1;
-  else
-    return f2;
+    if (s == 1)
+        return f1;
+    else
+        return f2;
 }
  
-int
-main ()
+int main()
 {
-  int *(*(*fp2) (int)) (int *, const int *) = fun;
+    int* (*(*fp2)(int))(int*, const int*) = fun;
  
-  int a = 15;
-  int b = 32;
-  fp2 (1) (&a, &b);
-  fp2 (2) (&b, &a);
-  printf ("%d %d\n", a, b);
-  return 0;
+    int a = 15;
+    int b = 32;
+    fp2(1)(&a, &b);
+    fp2(2)(&b, &a);
+    printf("%d %d\n", a, b);
+    return 0;
 }
@@ -4,47 +4,46 @@ using namespace std;
  
 list::list()
 {
-  head = NULL;
-  current = NULL;
+    head = NULL;
+    current = NULL;
 }
  
 list::~list()
 {
-  while(head)
-  { 
-    node* t=head->next;
-    delete head;
-    head=t;
-  };
+    while (head) {
+        node* t = head->next;
+        delete head;
+        head = t;
+    };
 }
  
 void list::insert(int a)
 {
-  node* t=new node;
-  t->next=head;
-  head = t;
-  head->val = a;
+    node* t = new node;
+    t->next = head;
+    head = t;
+    head->val = a;
 }
  
 void list::goToHead()
 {
-  current=head;
+    current = head;
 }
  
 int list::getCurrentData()
 {
-  return current->val;
+    return current->val;
 }
  
 void list::advance()
 {
-  current=current->next;
+    current = current->next;
 }
  
 bool list::moreData()
 {
-  if(current)
-    return true;
-  else
-    return false;
+    if (current)
+        return true;
+    else
+        return false;
 }
-class list
-{
-private:
-  struct node
-  {
-    node *next;
-    int val;
-  };
-  node * head;
-  node *current;
-public:
-  list ();
-  ~list ();
-  void insert (int a);
-  void goToHead ();
-  int getCurrentData ();
-  void advance ();
-  bool moreData ();
+class list {
+  private:
+    struct node {
+        node* next;
+        int val;
+    };
+    node* head;
+    node* current;
+
+  public:
+    list();
+    ~list();
+    void insert(int a);
+    void goToHead();
+    int getCurrentData();
+    void advance();
+    bool moreData();
 };
@@ -4,17 +4,16 @@ using namespace std;
  
 int main()
 {
- list l;
- l.insert(1);
- l.insert(2);
- l.insert(3);
- l.goToHead();
- while(l.moreData())
- {
-   int val;
-   val=l.getCurrentData();
-   cout << val << " ";
-   l.advance();
- }
- cout << endl;
+    list l;
+    l.insert(1);
+    l.insert(2);
+    l.insert(3);
+    l.goToHead();
+    while (l.moreData()) {
+        int val;
+        val = l.getCurrentData();
+        cout << val << " ";
+        l.advance();
+    }
+    cout << endl;
 }
@@ -4,47 +4,46 @@ using namespace std;
  
 list::list()
 {
-  head = NULL;
-  current = NULL;
+    head = NULL;
+    current = NULL;
 }
  
 list::~list()
 {
-  while(head)
-  { 
-    node* t=head->next;
-    delete head;
-    head=t;
-  };
+    while (head) {
+        node* t = head->next;
+        delete head;
+        head = t;
+    };
 }
  
 void list::insert(int a)
 {
-  node* t=new node;
-  t->next=head;
-  head = t;
-  head->val = a;
+    node* t = new node;
+    t->next = head;
+    head = t;
+    head->val = a;
 }
  
 void list::goToHead()
 {
-  current=head;
+    current = head;
 }
  
 int list::getCurrentData()
 {
-  return current->val;
+    return current->val;
 }
  
 void list::advance()
 {
-  current=current->next;
+    current = current->next;
 }
  
 bool list::moreData()
 {
-  if(current)
-    return true;
-  else
-    return false;
+    if (current)
+        return true;
+    else
+        return false;
 }
-class list
-{
-private:
-  struct node
-  {
-    node *next;
-    int val;
-  };
-  node * head;
-  node *current;
-public:
-  list ();
-  ~list ();
-  void insert (int a);
-  void goToHead ();
-  int getCurrentData ();
-  void advance ();
-  bool moreData ();
+class list {
+  private:
+    struct node {
+        node* next;
+        int val;
+    };
+    node* head;
+    node* current;
+
+  public:
+    list();
+    ~list();
+    void insert(int a);
+    void goToHead();
+    int getCurrentData();
+    void advance();
+    bool moreData();
 };
@@ -2,33 +2,28 @@
 using namespace std;
 #include "list.h"
  
-
-void
-PrintList (list & toPrint, ostream & Out)
+void PrintList(list& toPrint, ostream& Out)
 {
-  int nextValue;
-  Out << "Printing list contents: " << endl;
-  toPrint.goToHead ();
-  if (!toPrint.moreData ())
-    {
-      Out << "List is empty" << endl;
-      return;
+    int nextValue;
+    Out << "Printing list contents: " << endl;
+    toPrint.goToHead();
+    if (!toPrint.moreData()) {
+        Out << "List is empty" << endl;
+        return;
     }
-  while (toPrint.moreData ())
-    {
-      nextValue = toPrint.getCurrentData ();
-      Out << nextValue << " ";
-      toPrint.advance ();
+    while (toPrint.moreData()) {
+        nextValue = toPrint.getCurrentData();
+        Out << nextValue << " ";
+        toPrint.advance();
     }
-  Out << endl;
+    Out << endl;
 }
  
-int
-main ()
+int main()
 {
-  list l;
-  l.insert (1);
-  l.insert (2);
-  l.insert (3);
-  PrintList (l, cout);
+    list l;
+    l.insert(1);
+    l.insert(2);
+    l.insert(3);
+    PrintList(l, cout);
 }
@@ -4,47 +4,46 @@ using namespace std;
  
 list::list()
 {
-  head = NULL;
-  current = NULL;
+    head = NULL;
+    current = NULL;
 }
  
 list::~list()
 {
-  while(head)
-  { 
-    node* t=head->next;
-    delete head;
-    head=t;
-  };
+    while (head) {
+        node* t = head->next;
+        delete head;
+        head = t;
+    };
 }
  
 void list::insert(int a)
 {
-  node* t=new node;
-  t->next=head;
-  head = t;
-  head->val = a;
+    node* t = new node;
+    t->next = head;
+    head = t;
+    head->val = a;
 }
  
 void list::goToHead()
 {
-  current=head;
+    current = head;
 }
  
 int list::getCurrentData()
 {
-  return current->val;
+    return current->val;
 }
  
 void list::advance()
 {
-  current=current->next;
+    current = current->next;
 }
  
 bool list::moreData()
 {
-  if(current)
-    return true;
-  else
-    return false;
+    if (current)
+        return true;
+    else
+        return false;
 }
-class list
-{
-private:
-  struct node
-  {
-    node *next;
-    int val;
-  };
-  node * head;
-  node *current;
-public:
-  list ();
-  ~list ();
-  void insert (int a);
-  void goToHead ();
-  int getCurrentData ();
-  void advance ();
-  bool moreData ();
+class list {
+  private:
+    struct node {
+        node* next;
+        int val;
+    };
+    node* head;
+    node* current;
+
+  public:
+    list();
+    ~list();
+    void insert(int a);
+    void goToHead();
+    int getCurrentData();
+    void advance();
+    bool moreData();
 };
@@ -2,34 +2,29 @@
 using namespace std;
 #include "list.h"
  
-
-void
-PrintList (list toPrint, ostream & Out)
+void PrintList(list toPrint, ostream& Out)
 {
-  int nextValue;
-  Out << "Printing list contents: " << endl;
-  toPrint.goToHead ();
-  if (!toPrint.moreData ())
-    {
-      Out << "List is empty" << endl;
-      return;
+    int nextValue;
+    Out << "Printing list contents: " << endl;
+    toPrint.goToHead();
+    if (!toPrint.moreData()) {
+        Out << "List is empty" << endl;
+        return;
     }
-  while (toPrint.moreData ())
-    {
-      nextValue = toPrint.getCurrentData ();
-      Out << nextValue << " ";
-      toPrint.advance ();
+    while (toPrint.moreData()) {
+        nextValue = toPrint.getCurrentData();
+        Out << nextValue << " ";
+        toPrint.advance();
     }
-  Out << endl;
+    Out << endl;
 }
  
-int
-main ()
+int main()
 {
-  list l;
-  l.insert (1);
-  l.insert (2);
-  l.insert (3);
-  PrintList (l, cout);
-  cout << endl;
+    list l;
+    l.insert(1);
+    l.insert(2);
+    l.insert(3);
+    PrintList(l, cout);
+    cout << endl;
 }
@@ -2,101 +2,92 @@
 using namespace std;
 #include "list.h"
  
-list::list ()
+list::list()
 {
-  head = NULL;
-  current = NULL;
+    head = NULL;
+    current = NULL;
 }
  
-list::~list ()
+list::~list()
 {
-  while (head)
-    {
-      node *t = head->next;
-      delete head;
-      head = t;
+    while (head) {
+        node* t = head->next;
+        delete head;
+        head = t;
     };
 }
  
-void
-list::insert (int a)
+void list::insert(int a)
 {
-  node *t = new node;
-  t->next = head;
-  head = t;
-  head->val = a;
+    node* t = new node;
+    t->next = head;
+    head = t;
+    head->val = a;
 }
  
-void
-list::goToHead ()
+void list::goToHead()
 {
-  current = head;
+    current = head;
 }
  
-int
-list::getCurrentData ()
+int list::getCurrentData()
 {
-  return current->val;
+    return current->val;
 }
  
-void
-list::advance ()
+void list::advance()
 {
-  current = current->next;
+    current = current->next;
 }
  
-bool
-list::moreData ()
+bool list::moreData()
 {
-  if (current)
-    return true;
-  else
-    return false;
+    if (current)
+        return true;
+    else
+        return false;
 }
  
-list::list (const list & l)
+list::list(const list& l)
 {
-  current=NULL;
-  node *src, **dst;
-  head = NULL;
-  src = l.head;
-  dst = &head;
-  while (src)
-    {
-      *dst = new node;
-      (*dst)->val = src->val;
-      (*dst)->next = NULL;
-      if(src==l.current)
-        current=*dst;
-      src = src->next;
-      dst = &((*dst)->next);
+    current = NULL;
+    node *src, **dst;
+    head = NULL;
+    src = l.head;
+    dst = &head;
+    while (src) {
+        *dst = new node;
+        (*dst)->val = src->val;
+        (*dst)->next = NULL;
+        if (src == l.current)
+            current = *dst;
+        src = src->next;
+        dst = &((*dst)->next);
     }
 }
  
-list & list::operator= (const list & l)
+list& list::operator=(const list& l)
 {
-  if (&l == this)
-    return *this;
-  current=NULL;
-  while (head)
-    {
-      node *t =	head->next;
-      delete head;
-      head = t;
+    if (&l == this)
+        return *this;
+    current = NULL;
+    while (head) {
+        node* t = head->next;
+        delete head;
+        head = t;
     };
-  node *src, **dst;
-  head = NULL;
-  src = l.head;
-  dst = &head;
-  while (src)
-    {
-      *dst = new node;
-      (*dst)->val = src->val;
-      (*dst)->next = NULL;
-      if(src==l.current)
-        current=*dst;
-      src = src->next;
-      dst = &((*dst)->next);
+    node *src, **dst;
+    head = NULL;
+    src = l.head;
+    dst = &head;
+    while (src) {
+        *dst = new node;
+        (*dst)->val = src->val;
+        (*dst)->next = NULL;
+        if (src == l.current)
+            current = *dst;
+        src = src->next;
+        dst = &((*dst)->next);
     }
-  return *this;
+    return *this;
 }
-class list
-{
-private:
-  struct node
-  {
-    node *next;
-    int val;
-  };
-  node * head;
-  node *current;
-public:
-  list ();
-  list (const list& l);
-  list& operator=(const list& l);
-  ~list ();
-  void insert (int a);
-  void goToHead ();
-  int getCurrentData ();
-  void advance ();
-  bool moreData ();
+class list {
+  private:
+    struct node {
+        node* next;
+        int val;
+    };
+    node* head;
+    node* current;
+
+  public:
+    list();
+    list(const list& l);
+    list& operator=(const list& l);
+    ~list();
+    void insert(int a);
+    void goToHead();
+    int getCurrentData();
+    void advance();
+    bool moreData();
 };
@@ -2,36 +2,31 @@
 using namespace std;
 #include "list.h"
  
-
-void
-PrintList (list toPrint, ostream & Out)
+void PrintList(list toPrint, ostream& Out)
 {
-  int nextValue;
-  Out << "Printing list contents: " << endl;
-  toPrint.goToHead ();
-  if (!toPrint.moreData ())
-    {
-      Out << "List is empty" << endl;
-      return;
+    int nextValue;
+    Out << "Printing list contents: " << endl;
+    toPrint.goToHead();
+    if (!toPrint.moreData()) {
+        Out << "List is empty" << endl;
+        return;
     }
-  while (toPrint.moreData ())
-    {
-      nextValue = toPrint.getCurrentData ();
-      Out << nextValue << " ";
-      toPrint.advance ();
+    while (toPrint.moreData()) {
+        nextValue = toPrint.getCurrentData();
+        Out << nextValue << " ";
+        toPrint.advance();
     }
-  Out << endl;
+    Out << endl;
 }
  
-int
-main ()
+int main()
 {
-  list l;
-  l.insert (1);
-  l.insert (2);
-  l.insert (3);
-  PrintList (l, cout);
-  list l2;
-  l2=l;
-  PrintList (l2,cout);
+    list l;
+    l.insert(1);
+    l.insert(2);
+    l.insert(3);
+    PrintList(l, cout);
+    list l2;
+    l2 = l;
+    PrintList(l2, cout);
 }
 #include <iostream>
  
-int
-addition (int a, int b)
+int addition(int a, int b)
 {
-  return (a + b);
+    return (a + b);
 }
  
-int
-subtraction (int a, int b)
+int subtraction(int a, int b)
 {
-  return (a - b);
+    return (a - b);
 }
  
-int (*minus) (int, int) = subtraction;
-int
-operation (int x, int y, int (*functocall) (int, int))
+int (*minus)(int, int) = subtraction;
+int operation(int x, int y, int (*functocall)(int, int))
 {
-  int g;
-  g = (*functocall) (x, y);
-  return (g);
+    int g;
+    g = (*functocall)(x, y);
+    return (g);
 }
  
-int
-main ()
+int main()
 {
-  int m, n;
-  m = operation (7, 5, addition);
-  n = operation (20, m, minus);
-  std::cout << n << std::endl;
-  return 0;
+    int m, n;
+    m = operation(7, 5, addition);
+    n = operation(20, m, minus);
+    std::cout << n << std::endl;
+    return 0;
 }
@@ -5,75 +5,71 @@
  
 using namespace std;
  
-class Complex
-{
-private:
-  double Real, Imag;
-public:
-    Complex ():Real (0), Imag (0)
-  {
-  };
+class Complex {
+  private:
+    double Real, Imag;
  
-  Complex (double co)
-  {
-    Real = co;
-    Imag = 0;
-  };
+  public:
+    Complex() : Real(0), Imag(0){};
  
-  Complex (double Real, double Imag)
-  {
-    this->Real = Real;
-    this->Imag = Imag;
-  };
+    Complex(double co)
+    {
+        Real = co;
+        Imag = 0;
+    };
  
-  Complex & operator= (const Complex & s)
-  {
-    Real = s.Real;
-    Imag = s.Imag;
-    return *this;
-  };
+    Complex(double Real, double Imag)
+    {
+        this->Real = Real;
+        this->Imag = Imag;
+    };
  
-  Complex operator- () const
-  {
-    return Complex(-Real,-Imag);
-  };
+    Complex& operator=(const Complex& s)
+    {
+        Real = s.Real;
+        Imag = s.Imag;
+        return *this;
+    };
  
-  Complex & operator= (double co)
-  {
-    Real = co;
-    Imag = 0;
-    return *this;
-  };
+    Complex operator-() const
+    {
+        return Complex(-Real, -Imag);
+    };
  
-  Complex operator+ (const Complex& co) const
-  {
-    Complex n;
-    n.Real = this->Real + co.Real;
-    n.Imag = this->Imag + co.Imag;
-    return n;
-  };
+    Complex& operator=(double co)
+    {
+        Real = co;
+        Imag = 0;
+        return *this;
+    };
  
+    Complex operator+(const Complex& co) const
+    {
+        Complex n;
+        n.Real = this->Real + co.Real;
+        n.Imag = this->Imag + co.Imag;
+        return n;
+    };
  
-  Complex & operator-= (Complex co)
-  {
-    Real -= co.Real;
-    Imag -= co.Imag;
-    return *this;
-  };
+    Complex& operator-=(Complex co)
+    {
+        Real -= co.Real;
+        Imag -= co.Imag;
+        return *this;
+    };
  
-  friend Complex operator- (Complex, Complex);
-  friend ostream & operator << (ostream & s, const Complex & c)
-  {
-    s << "(" << c.Real << "," << c.Imag << ")";
-    return s;
-  };
+    friend Complex operator-(Complex, Complex);
+    friend ostream& operator<<(ostream& s, const Complex& c)
+    {
+        s << "(" << c.Real << "," << c.Imag << ")";
+        return s;
+    };
 };
  
-inline Complex
-operator - (Complex s1, Complex s2)
+inline Complex operator-(Complex s1, Complex s2)
 {
-  Complex n (s1);
-  return n -= s2;
+    Complex n(s1);
+    return n -= s2;
 }
  
 #endif /* __Complex_H__ */
@@ -2,18 +2,17 @@
 using namespace std;
 #include "complex.h"
  
-
 int main()
 {
-  Complex a(0.0,15),b(0,13),c;
-  c = 10;
-  cout << c <<endl;
-  c = -a;
-  cout << c <<endl;  
-  c = a + b;
-  c = c - Complex(10);
-  cout << c <<endl;  
-  c = 10 - a;
-  (c -=b) -=10;
-  cout << c <<endl;
+    Complex a(0.0, 15), b(0, 13), c;
+    c = 10;
+    cout << c << endl;
+    c = -a;
+    cout << c << endl;
+    c = a + b;
+    c = c - Complex(10);
+    cout << c << endl;
+    c = 10 - a;
+    (c -= b) -= 10;
+    cout << c << endl;
 }
@@ -2,21 +2,18 @@
 using namespace std;
 #include "vector.h"
  
-void
-printvector (vector  v)
+void printvector(vector v)
 {
-  cout << v << endl;
+    cout << v << endl;
 }
  
-int
-main ()
+int main()
 {
-  vector a (10);
-  cout << a << endl;
-  a[0] = 15;
-  a[5] = 32;
-  vector b(10);
-  b=a;
-  printvector (b);
+    vector a(10);
+    cout << a << endl;
+    a[0] = 15;
+    a[5] = 32;
+    vector b(10);
+    b = a;
+    printvector(b);
 }
-
 #ifndef __VECTOR_H__
 #define __VECTOR_H__
  
-class vector
-{
-  int *dane;
-  unsigned int size;
-public:
-    vector (int s)
-  {
-    dane = new int[s];
-      size = s;
-    for (unsigned i = 0; i < size; i++)
-        dane[i] = 0;
-  }
-   ~vector ()
-  {
-    delete [] dane;
-  }
-  int& operator[] (unsigned int pos)
-  {
-    if (pos >= size)
-      abort ();
-    return dane[pos];
-  }
-  int operator[] (unsigned int pos) const
-  {
-    if (pos >= size)
-      abort ();
-    return dane[pos];
-  }
+class vector {
+    int* dane;
+    unsigned int size;
  
-  vector (const vector & s)
-  {
-    dane = new int[s.size];
-    size = s.size;
-    for (unsigned i = 0; i < size; i++)
-      dane[i] = s.dane[i];
-  }
-  vector & operator= (const vector & s)
-  {
-    if (this == &s)
-      return *this;
-    delete [] dane;
-    dane = new int[s.size];
-    size = s.size;
-    for (unsigned i = 0; i < size; i++)
-      dane[i] = s.dane[i];
-    return *this;
-  }
-  friend ostream & operator<< (ostream & o, const vector & v)
-  {
-    o << '[';
-    for (unsigned i = 0; i < v.size;i++)
-      {
-	o << v[i];
-	if (i != v.size - 1)
-	  o << ',';
-      };
-    o << ']';
-    return o;
-  }
+  public:
+    vector(int s)
+    {
+        dane = new int[s];
+        size = s;
+        for (unsigned i = 0; i < size; i++)
+            dane[i] = 0;
+    }
+    ~vector()
+    {
+        delete[] dane;
+    }
+    int& operator[](unsigned int pos)
+    {
+        if (pos >= size)
+            abort();
+        return dane[pos];
+    }
+    int operator[](unsigned int pos) const
+    {
+        if (pos >= size)
+            abort();
+        return dane[pos];
+    }
+
+    vector(const vector& s)
+    {
+        dane = new int[s.size];
+        size = s.size;
+        for (unsigned i = 0; i < size; i++)
+            dane[i] = s.dane[i];
+    }
+    vector& operator=(const vector& s)
+    {
+        if (this == &s)
+            return *this;
+        delete[] dane;
+        dane = new int[s.size];
+        size = s.size;
+        for (unsigned i = 0; i < size; i++)
+            dane[i] = s.dane[i];
+        return *this;
+    }
+    friend ostream& operator<<(ostream& o, const vector& v)
+    {
+        o << '[';
+        for (unsigned i = 0; i < v.size; i++) {
+            o << v[i];
+            if (i != v.size - 1)
+                o << ',';
+        };
+        o << ']';
+        return o;
+    }
 };
 #endif /* __VECTOR_H__ */
 #ifndef __MYSTRING_H__
 #define __MYSTRING_H__
  
-class mystring
-{
-  char *dane;
-public:
-  mystring ():dane (0)
-  {
-  };
-  ~mystring ()
-  {
-    delete[]dane;
-  };
-  mystring (const char *s)
-  {
-    if (s)
-      {
-	dane = new char[strlen (s) + 1];
-	strcpy (dane, s);
-      }
-    else
-      dane = 0;
-  };
-
-  unsigned int length () const
-  {
-    if (!dane)
-      return 0;
-    else
-      return strlen (dane);
-  }
-
-  mystring (const mystring & src)
-  {
-    if (src.dane)
-      {
-	dane = new char[strlen (src.dane) + 1];
-	strcpy (dane, src.dane);
-      }
-    else
-      dane = 0;
-  };
-  mystring & operator= (const mystring & src)
-  {
-    if (this != &src)
-      {
-	delete[]dane;
-	if (src.dane)
-	  {
-	    dane = new char[strlen (src.dane) + 1];
-	    strcpy (dane, src.dane);
-	  }
-	else
-	  dane = 0;
-      };
-    return *this;
-  }
+class mystring {
+    char* dane;
  
-  mystring & operator+= (const mystring & src)
-  {
-    char *newstr = new char[length () + src.length () + 1];
-    if (length ())
-      strcpy (newstr, dane);
-    else
-      newstr[0] = '\0';
-    if (src.length ())
-      strcat (newstr, src.dane);
-    delete[]dane;
-    dane = newstr;
-    return *this;
-  }
+  public:
+    mystring() : dane(0){};
+    ~mystring()
+    {
+        delete[] dane;
+    };
+    mystring(const char* s)
+    {
+        if (s) {
+            dane = new char[strlen(s) + 1];
+            strcpy(dane, s);
+        }
+        else
+            dane = 0;
+    };
  
+    unsigned int length() const
+    {
+        if (!dane)
+            return 0;
+        else
+            return strlen(dane);
+    }
  
-  char operator[] (unsigned int i) const
-  {
-    if (!dane)
-      abort ();
-    if (i >= strlen (dane))
-      abort ();
-    return dane[i];
-  }
-  char &operator[] (unsigned int i)
-  {
-    if (!dane)
-      abort ();
-    if (i >= strlen (dane))
-      abort ();
-    return dane[i];
-  }
+    mystring(const mystring& src)
+    {
+        if (src.dane) {
+            dane = new char[strlen(src.dane) + 1];
+            strcpy(dane, src.dane);
+        }
+        else
+            dane = 0;
+    };
+    mystring& operator=(const mystring& src)
+    {
+        if (this != &src) {
+            delete[] dane;
+            if (src.dane) {
+                dane = new char[strlen(src.dane) + 1];
+                strcpy(dane, src.dane);
+            }
+            else
+                dane = 0;
+        };
+        return *this;
+    }
  
-  friend ostream & operator<< (ostream & o, const mystring & s)
-  {
-    if (s.dane)
-      o << s.dane;
-    return o;
-  }
+    mystring& operator+=(const mystring& src)
+    {
+        char* newstr = new char[length() + src.length() + 1];
+        if (length())
+            strcpy(newstr, dane);
+        else
+            newstr[0] = '\0';
+        if (src.length())
+            strcat(newstr, src.dane);
+        delete[] dane;
+        dane = newstr;
+        return *this;
+    }
  
+    char operator[](unsigned int i) const
+    {
+        if (!dane)
+            abort();
+        if (i >= strlen(dane))
+            abort();
+        return dane[i];
+    }
+    char& operator[](unsigned int i)
+    {
+        if (!dane)
+            abort();
+        if (i >= strlen(dane))
+            abort();
+        return dane[i];
+    }
  
+    friend ostream& operator<<(ostream& o, const mystring& s)
+    {
+        if (s.dane)
+            o << s.dane;
+        return o;
+    }
 };
  
-  inline mystring operator+ (const mystring & s1, const mystring & s2)
-  {
-    mystring s (s1);
+inline mystring operator+(const mystring& s1, const mystring& s2)
+{
+    mystring s(s1);
     return s += s2;
-  }
-
+}
  
 #endif /* __MYSTRING_H__ */
-#include <string.h>
 #include <iostream>
+#include <string.h>
 using namespace std;
 #include "mystring.h"
  
 int main()
 {
-  mystring a("ala");
-  mystring b=a;
-  b[0]='c';
-  cout << b << endl;
-  mystring c=a+b;
-  c+="ola";
-  cout << c+"ula"<<endl;
+    mystring a("ala");
+    mystring b = a;
+    b[0] = 'c';
+    cout << b << endl;
+    mystring c = a + b;
+    c += "ola";
+    cout << c + "ula" << endl;
 }
 #ifndef __MYSTRING_H__
 #define __MYSTRING_H__
  
-class mystring
-{
-  char *dane;
-public:
-  mystring ():dane (0)
-  {
-  };
-  ~mystring ()
-  {
-    delete[]dane;
-  };
-  mystring (const char *s)
-  {
-    if (s)
-      {
-	dane = new char[strlen (s) + 1];
-	strcpy (dane, s);
-      }
-    else
-      dane = 0;
-  };
+class mystring {
+    char* dane;
  
-  unsigned int length () const
-  {
-    if (!dane)
-      return 0;
-    else
-      return strlen (dane);
-  }
+  public:
+    mystring() : dane(0){};
+    ~mystring()
+    {
+        delete[] dane;
+    };
+    mystring(const char* s)
+    {
+        if (s) {
+            dane = new char[strlen(s) + 1];
+            strcpy(dane, s);
+        }
+        else
+            dane = 0;
+    };
  
-  mystring (const mystring & src)
-  {
-    if (src.dane)
-      {
-	dane = new char[strlen (src.dane) + 1];
-	strcpy (dane, src.dane);
-      }
-    else
-      dane = 0;
-  };
-  mystring & operator= (const mystring & src)
-  {
-    if (this != &src)
-      {
-	delete[]dane;
-	if (src.dane)
-	  {
-	    dane = new char[strlen (src.dane) + 1];
-	    strcpy (dane, src.dane);
-	  }
-	else
-	  dane = 0;
-      };
-    return *this;
-  }
+    unsigned int length() const
+    {
+        if (!dane)
+            return 0;
+        else
+            return strlen(dane);
+    }
  
-  mystring & operator+= (const mystring & src)
-  {
-    char *newstr = new char[length () + src.length () + 1];
-    if (length ())
-      strcpy (newstr, dane);
-    else
-      newstr[0] = '\0';
-    if (src.length ())
-      strcat (newstr, src.dane);
-    delete[]dane;
-    dane = newstr;
-    return *this;
-  }
+    mystring(const mystring& src)
+    {
+        if (src.dane) {
+            dane = new char[strlen(src.dane) + 1];
+            strcpy(dane, src.dane);
+        }
+        else
+            dane = 0;
+    };
+    mystring& operator=(const mystring& src)
+    {
+        if (this != &src) {
+            delete[] dane;
+            if (src.dane) {
+                dane = new char[strlen(src.dane) + 1];
+                strcpy(dane, src.dane);
+            }
+            else
+                dane = 0;
+        };
+        return *this;
+    }
  
-  operator char*()
-  {
-    if(!dane) 
+    mystring& operator+=(const mystring& src)
     {
-      dane=new char[1];
-      dane[0]='\0';
+        char* newstr = new char[length() + src.length() + 1];
+        if (length())
+            strcpy(newstr, dane);
+        else
+            newstr[0] = '\0';
+        if (src.length())
+            strcat(newstr, src.dane);
+        delete[] dane;
+        dane = newstr;
+        return *this;
     }
-    return dane;
-  };
  
-  friend ostream & operator<< (ostream & o, const mystring & s)
-  {
-    if (s.dane)
-      o << s.dane;
-    return o;
-  }
+    operator char*()
+    {
+        if (!dane) {
+            dane = new char[1];
+            dane[0] = '\0';
+        }
+        return dane;
+    };
+
+    friend ostream& operator<<(ostream& o, const mystring& s)
+    {
+        if (s.dane)
+            o << s.dane;
+        return o;
+    }
 };
  
-  inline mystring operator+ (const mystring & s1, const mystring & s2)
-  {
-    mystring s (s1);
+inline mystring operator+(const mystring& s1, const mystring& s2)
+{
+    mystring s(s1);
     return s += s2;
-  }
-
+}
  
 #endif /* __MYSTRING_H__ */
-#include <string.h>
 #include <iostream>
+#include <string.h>
 using namespace std;
 #include "mystring.h"
  
 int main()
 {
-  mystring a("ala");
-  mystring b=a;
-  b[0]='c';
-  cout << b << endl;
-  mystring c=a+b;
-  c+="ola";
-  cout << c+"ula"<<endl;
-  mystring d;
-  cout << strlen(d)<<endl;
+    mystring a("ala");
+    mystring b = a;
+    b[0] = 'c';
+    cout << b << endl;
+    mystring c = a + b;
+    c += "ola";
+    cout << c + "ula" << endl;
+    mystring d;
+    cout << strlen(d) << endl;
 }
 #include <iostream>
 using namespace std;
  
-class myexception{};
+class myexception {};
  
-class tester
-{
-  string name;
-public:
-  tester(const string& n): name(n)
-  {
-    cout<<name<<"()"<<endl;  
-  };
-  ~tester()
-  {
-    cout<<"~"<<name<<"()"<<endl;
-  };
+class tester {
+    string name;
+
+  public:
+    tester(const string& n) : name(n)
+    {
+        cout << name << "()" << endl;
+    };
+    ~tester()
+    {
+        cout << "~" << name << "()" << endl;
+    };
 };
  
 void f1()
 {
-  tester f1("f1");
-  throw myexception();
-  cout << "Exiting f1"<<endl;
+    tester f1("f1");
+    throw myexception();
+    cout << "Exiting f1" << endl;
 }
  
 void f2()
 {
-  tester f2("f2");
-  f1();
-  cout << "Exiting f2"<<endl;
+    tester f2("f2");
+    f1();
+    cout << "Exiting f2" << endl;
 }
-  
+
 int main()
 {
-  tester main("main");
-  try {
-  f2();
-  } catch(myexception&)
-  {
-    cout << "myxception caught"<<endl;
-  }
-  return 0;
+    tester main("main");
+    try {
+        f2();
+    }
+    catch (myexception&) {
+        cout << "myxception caught" << endl;
+    }
+    return 0;
 }
 #include <iostream>
 using namespace std;
  
-class myexception{};
+class myexception {};
  
-class tester
-{
-  string name;
-public:
-  tester(const string& n): name(n)
-  {
-    cout<<name<<"()"<<endl;  
-  };
-  ~tester()
-  {
-    cout<<"~"<<name<<"()"<<endl;
-  };
+class tester {
+    string name;
+
+  public:
+    tester(const string& n) : name(n)
+    {
+        cout << name << "()" << endl;
+    };
+    ~tester()
+    {
+        cout << "~" << name << "()" << endl;
+    };
 };
  
 void f1()
 {
-  tester f1("f1");
-  throw myexception();
-  cout << "Exiting f1"<<endl;
+    tester f1("f1");
+    throw myexception();
+    cout << "Exiting f1" << endl;
 }
  
 void f2()
 {
-  tester f2("f2");
-  f1();
-  cout << "Exiting f2"<<endl;
+    tester f2("f2");
+    f1();
+    cout << "Exiting f2" << endl;
 }
-  
+
 int main()
 {
-  tester main("main");
-  f2();
-  return 0;
+    tester main("main");
+    f2();
+    return 0;
 }
@@ -2,25 +2,24 @@
 #include <memory>
 using namespace std;
  
-
 void f1()
 {
-  int *a = new int[500000000];
-  delete [] a;
+    int* a = new int[500000000];
+    delete[] a;
 }
  
 void f2()
 {
-  f1();
+    f1();
 }
-  
+
 int main()
 {
-try {
-  f2();
-}
-catch(bad_alloc&) {
-  cout << "bad_alloc"<<endl;
-}
-  return 0;
+    try {
+        f2();
+    }
+    catch (bad_alloc&) {
+        cout << "bad_alloc" << endl;
+    }
+    return 0;
 }
 #ifndef __MYSTRING_H__
 #define __MYSTRING_H__
  
-class mystring
-{
-  char *dane;
-public:
-  class index_out_of_range{};
-  mystring ():dane (0)
-  {
-  };
-  ~mystring ()
-  {
-    delete[]dane;
-  };
-  mystring (const char *s)
-  {
-    if (s)
-      {
-	dane = new char[strlen (s) + 1];
-	strcpy (dane, s);
-      }
-    else
-      dane = 0;
-  };
-
-  unsigned int length () const
-  {
-    if (!dane)
-      return 0;
-    else
-      return strlen (dane);
-  }
-
-  mystring (const mystring & src)
-  {
-    if (src.dane)
-      {
-	dane = new char[strlen (src.dane) + 1];
-	strcpy (dane, src.dane);
-      }
-    else
-      dane = 0;
-  };
-  mystring & operator= (const mystring & src)
-  {
-    if (this != &src)
-      {
-	char* nowedane;
-	if (src.dane)
-	  {
-	    nowedane = new char[strlen (src.dane) + 1];
-	    strcpy (nowedane, src.dane);
-	  }
-	else
-	  nowedane = 0;
-	delete [] dane;
-	dane=nowedane;
-      };
-    return *this;
-  }
+class mystring {
+    char* dane;
  
-  mystring & operator+= (const mystring & src)
-  {
-    char *newstr = new char[length () + src.length () + 1];
-    if (length ())
-      strcpy (newstr, dane);
-    else
-      newstr[0] = '\0';
-    if (src.length ())
-      strcat (newstr, src.dane);
-    delete[]dane;
-    dane = newstr;
-    return *this;
-  }
+  public:
+    class index_out_of_range {};
+    mystring() : dane(0){};
+    ~mystring()
+    {
+        delete[] dane;
+    };
+    mystring(const char* s)
+    {
+        if (s) {
+            dane = new char[strlen(s) + 1];
+            strcpy(dane, s);
+        }
+        else
+            dane = 0;
+    };
  
+    unsigned int length() const
+    {
+        if (!dane)
+            return 0;
+        else
+            return strlen(dane);
+    }
  
-  char operator[] (unsigned int i) const
-  {
-    if (!dane)
-      throw index_out_of_range();
-    if (i >= strlen (dane))
-      throw index_out_of_range();
-    return dane[i];
-  }
-  char &operator[] (unsigned int i)
-  {
-    if (!dane)
-      throw index_out_of_range();
-    if (i >= strlen (dane))
-      throw index_out_of_range();
-    return dane[i];
-  }
+    mystring(const mystring& src)
+    {
+        if (src.dane) {
+            dane = new char[strlen(src.dane) + 1];
+            strcpy(dane, src.dane);
+        }
+        else
+            dane = 0;
+    };
+    mystring& operator=(const mystring& src)
+    {
+        if (this != &src) {
+            char* nowedane;
+            if (src.dane) {
+                nowedane = new char[strlen(src.dane) + 1];
+                strcpy(nowedane, src.dane);
+            }
+            else
+                nowedane = 0;
+            delete[] dane;
+            dane = nowedane;
+        };
+        return *this;
+    }
  
-  friend ostream & operator<< (ostream & o, const mystring & s)
-  {
-    if (s.dane)
-      o << s.dane;
-    return o;
-  }
+    mystring& operator+=(const mystring& src)
+    {
+        char* newstr = new char[length() + src.length() + 1];
+        if (length())
+            strcpy(newstr, dane);
+        else
+            newstr[0] = '\0';
+        if (src.length())
+            strcat(newstr, src.dane);
+        delete[] dane;
+        dane = newstr;
+        return *this;
+    }
  
+    char operator[](unsigned int i) const
+    {
+        if (!dane)
+            throw index_out_of_range();
+        if (i >= strlen(dane))
+            throw index_out_of_range();
+        return dane[i];
+    }
+    char& operator[](unsigned int i)
+    {
+        if (!dane)
+            throw index_out_of_range();
+        if (i >= strlen(dane))
+            throw index_out_of_range();
+        return dane[i];
+    }
  
+    friend ostream& operator<<(ostream& o, const mystring& s)
+    {
+        if (s.dane)
+            o << s.dane;
+        return o;
+    }
 };
  
-  inline mystring operator+ (const mystring & s1, const mystring & s2)
-  {
-    mystring s (s1);
+inline mystring operator+(const mystring& s1, const mystring& s2)
+{
+    mystring s(s1);
     return s += s2;
-  }
-
+}
  
 #endif /* __MYSTRING_H__ */
-#include <string.h>
 #include <iostream>
+#include <string.h>
 using namespace std;
 #include "mystring.h"
  
 int main()
 {
-  mystring a("ala");
-  mystring b=a;
-  b[0]='c';
-  cout << b << endl;
-  mystring c=a+b;
-  c+="ola";
-  cout << c+"ula"<<endl;
-  try {
-  c[40]='a';
-  } catch (mystring::index_out_of_range&)
-  {
-    cout << "Index out of range" << endl;
-  };
+    mystring a("ala");
+    mystring b = a;
+    b[0] = 'c';
+    cout << b << endl;
+    mystring c = a + b;
+    c += "ola";
+    cout << c + "ula" << endl;
+    try {
+        c[40] = 'a';
+    }
+    catch (mystring::index_out_of_range&) {
+        cout << "Index out of range" << endl;
+    };
 }
@@ -2,24 +2,24 @@
  
 int main()
 {
-rcstring a,b,c;
-a="10";
-b="ala ma kota";
-cout << a << " " << b << endl; // 10 ala ma ma kota
-c=a+b;
-cout << c<<endl; // 10ala ma kota
-c=a+rcstring(" ")+b;
-cout << c << endl; //10 ala ma kota
-rcstring d("a");
-cout << d <<endl; //a
-d+="ula";
-cout << d << endl; //aula
-d+="15";
-cout << d << endl; //aula15
-cout << d[3]<<endl; //a
-d[3]='b';
-cout << d << endl; //aulb15
-d[2]=d[1]=d[0];
-cout << d << endl; //aaab15
-return 0;
+    rcstring a, b, c;
+    a = "10";
+    b = "ala ma kota";
+    cout << a << " " << b << endl; // 10 ala ma ma kota
+    c = a + b;
+    cout << c << endl; // 10ala ma kota
+    c = a + rcstring(" ") + b;
+    cout << c << endl; // 10 ala ma kota
+    rcstring d("a");
+    cout << d << endl; // a
+    d += "ula";
+    cout << d << endl; // aula
+    d += "15";
+    cout << d << endl;    // aula15
+    cout << d[3] << endl; // a
+    d[3] = 'b';
+    cout << d << endl; // aulb15
+    d[2] = d[1] = d[0];
+    cout << d << endl; // aaab15
+    return 0;
 }
 #ifndef __RCSTRING_H__
 #define __RCSTRING_H__
-#include <string.h>
-#include <stdio.h>
-#include <malloc.h>
 #include <iostream>
+#include <malloc.h>
+#include <stdio.h>
+#include <string.h>
 using namespace std;
  
-class rcstring{
-  struct rctext;
-  rctext* data;
-public:
-class Range{};
-rcstring();
-rcstring(const char*);
-rcstring(const rcstring&);
-~rcstring();
-rcstring& operator=(const rcstring&);
-rcstring& operator+=(const rcstring &);
-rcstring operator+(const rcstring &) const;
-friend ostream& operator<<(ostream&, const rcstring&);
-void check (unsigned int i) const;
-char read(unsigned int i) const;
-void write(unsigned int i, char c);
-
-char operator[](unsigned int i) const;
-char& operator[](unsigned int i);
+class rcstring {
+    struct rctext;
+    rctext* data;
+
+  public:
+    class Range {};
+    rcstring();
+    rcstring(const char*);
+    rcstring(const rcstring&);
+    ~rcstring();
+    rcstring& operator=(const rcstring&);
+    rcstring& operator+=(const rcstring&);
+    rcstring operator+(const rcstring&) const;
+    friend ostream& operator<<(ostream&, const rcstring&);
+    void check(unsigned int i) const;
+    char read(unsigned int i) const;
+    void write(unsigned int i, char c);
+
+    char operator[](unsigned int i) const;
+    char& operator[](unsigned int i);
 };
  
-struct rcstring::rctext
-{
-  char* s;
-  unsigned int size;
-  unsigned int n;
-
-  rctext(unsigned int nsize, const char* p)
-  {
-    n=1;
-    size=nsize;
-    s=new char[size+1];
-    strncpy(s,p,size);
-    s[size]='\0';
-  };
-  ~rctext()
-  {
-    delete [] s;
-  };
-  rctext* detach()
-  {
-    if(n==1)
-      return this;
-    rctext* t=new rctext(size, s);
-    n--;
-    return t;
-  };
-private:
-  rctext(const rctext&);
-  rctext& operator=(const rctext&);
+struct rcstring::rctext {
+    char* s;
+    unsigned int size;
+    unsigned int n;
+
+    rctext(unsigned int nsize, const char* p)
+    {
+        n = 1;
+        size = nsize;
+        s = new char[size + 1];
+        strncpy(s, p, size);
+        s[size] = '\0';
+    };
+    ~rctext()
+    {
+        delete[] s;
+    };
+    rctext* detach()
+    {
+        if (n == 1)
+            return this;
+        rctext* t = new rctext(size, s);
+        n--;
+        return t;
+    };
+
+  private:
+    rctext(const rctext&);
+    rctext& operator=(const rctext&);
 };
  
 inline rcstring::rcstring()
-  {
-    data = new rctext(0,"");
-  }
+{
+    data = new rctext(0, "");
+}
  
 inline rcstring::rcstring(const rcstring& x)
-  {
+{
     x.data->n++;
-    data=x.data;
-  }
+    data = x.data;
+}
 inline rcstring::~rcstring()
 {
-  if(--data->n==0)
-    delete data;
+    if (--data->n == 0)
+        delete data;
 }
  
-rcstring& rcstring::operator=(const rcstring & x)
+rcstring& rcstring::operator=(const rcstring& x)
 {
-  x.data->n++;
-  if(--data->n == 0)
-    delete data;
-  data=x.data;
-  return *this;
+    x.data->n++;
+    if (--data->n == 0)
+        delete data;
+    data = x.data;
+    return *this;
 }
  
 rcstring::rcstring(const char* s)
 {
- data=new rctext(strlen(s),s);
+    data = new rctext(strlen(s), s);
 }
  
-ostream& operator << (ostream& o, const rcstring& s)
+ostream& operator<<(ostream& o, const rcstring& s)
 {
-  return o<<s.data->s;
+    return o << s.data->s;
 }
  
-rcstring& rcstring::operator+=(const rcstring & s)
+rcstring& rcstring::operator+=(const rcstring& s)
 {
-unsigned int newsize=data->size+s.data->size;
-rctext *newdata=new rctext(newsize,data->s);
-strcat(newdata->s,s.data->s);
-if(--data->n==0)
-  delete data;
-data = newdata;
-return *this;
+    unsigned int newsize = data->size + s.data->size;
+    rctext* newdata = new rctext(newsize, data->s);
+    strcat(newdata->s, s.data->s);
+    if (--data->n == 0)
+        delete data;
+    data = newdata;
+    return *this;
 }
  
-rcstring rcstring::operator+(const rcstring & s) const
+rcstring rcstring::operator+(const rcstring& s) const
 {
-  return rcstring(*this)+=s;
+    return rcstring(*this) += s;
 }
  
-inline void rcstring::check (unsigned int i) const
+inline void rcstring::check(unsigned int i) const
 {
-if(data->size<=i)
-  throw Range();
+    if (data->size <= i)
+        throw Range();
 }
  
 inline char rcstring::read(unsigned int i) const
 {
- return data->s[i];
+    return data->s[i];
 }
  
 inline void rcstring::write(unsigned int i, char c)
 {
-  data = data->detach();
-  data->s[i] = c;
+    data = data->detach();
+    data->s[i] = c;
 }
  
 char rcstring::operator[](unsigned int i) const
 {
-  cout << "char rcstring::operator[](unsigned int i) const"<<endl;
-  check(i);
-  return data->s[i];
+    cout << "char rcstring::operator[](unsigned int i) const" << endl;
+    check(i);
+    return data->s[i];
 }
  
 char& rcstring::operator[](unsigned int i)
 {
-  cout << "char& rcstring::operator[](unsigned int i)"<<endl;
-  check(i);
-  data = data->detach();
-  return data->s[i];
+    cout << "char& rcstring::operator[](unsigned int i)" << endl;
+    check(i);
+    data = data->detach();
+    return data->s[i];
 }
  
 #endif /* __RCSTRING_H__ */
@@ -2,24 +2,24 @@
  
 int main()
 {
-rcstring a,b,c;
-a="10";
-b="ala ma kota";
-cout << a << " " << b << endl; // 10 ala ma ma kota
-c=a+b;
-cout << c<<endl; // 10ala ma kota
-c=a+rcstring(" ")+b;
-cout << c << endl; //10 ala ma kota
-rcstring d("a");
-cout << d <<endl; //a
-d+="ula";
-cout << d << endl; //aula
-d+="15";
-cout << d << endl; //aula15
-cout << d[3]<<endl; //a
-d[3]='b';
-cout << d << endl; //aulb15
-d[2]=d[1]=d[0];
-cout << d << endl; //aaab15
-return 0;
+    rcstring a, b, c;
+    a = "10";
+    b = "ala ma kota";
+    cout << a << " " << b << endl; // 10 ala ma ma kota
+    c = a + b;
+    cout << c << endl; // 10ala ma kota
+    c = a + rcstring(" ") + b;
+    cout << c << endl; // 10 ala ma kota
+    rcstring d("a");
+    cout << d << endl; // a
+    d += "ula";
+    cout << d << endl; // aula
+    d += "15";
+    cout << d << endl;    // aula15
+    cout << d[3] << endl; // a
+    d[3] = 'b';
+    cout << d << endl; // aulb15
+    d[2] = d[1] = d[0];
+    cout << d << endl; // aaab15
+    return 0;
 }
 #ifndef __RCSTRING_H__
 #define __RCSTRING_H__
-#include <string.h>
-#include <stdio.h>
-#include <malloc.h>
 #include <iostream>
+#include <malloc.h>
+#include <stdio.h>
+#include <string.h>
 using namespace std;
  
-class rcstring{
-  struct rctext;
-  rctext* data;
-public:
-class Range{};
-class Cref;
-rcstring();
-rcstring(const char*);
-rcstring(const rcstring&);
-~rcstring();
-rcstring& operator=(const rcstring&);
-rcstring& operator+=(const rcstring &);
-rcstring operator+(const rcstring &) const;
-friend ostream& operator<<(ostream&, const rcstring&);
-void check (unsigned int i) const;
-char read(unsigned int i) const;
-void write(unsigned int i, char c);
-char operator[](unsigned int i) const;
-Cref operator[](unsigned int i);
+class rcstring {
+    struct rctext;
+    rctext* data;
+
+  public:
+    class Range {};
+    class Cref;
+    rcstring();
+    rcstring(const char*);
+    rcstring(const rcstring&);
+    ~rcstring();
+    rcstring& operator=(const rcstring&);
+    rcstring& operator+=(const rcstring&);
+    rcstring operator+(const rcstring&) const;
+    friend ostream& operator<<(ostream&, const rcstring&);
+    void check(unsigned int i) const;
+    char read(unsigned int i) const;
+    void write(unsigned int i, char c);
+    char operator[](unsigned int i) const;
+    Cref operator[](unsigned int i);
 };
  
-struct rcstring::rctext
-{
-  char* s;
-  unsigned int size;
-  unsigned int n;
-
-  rctext(unsigned int nsize, const char* p)
-  {
-    n=1;
-    size=nsize;
-    s=new char[size+1];
-    strncpy(s,p,size);
-    s[size]='\0';
-  };
-  ~rctext()
-  {
-    delete [] s;
-  };
-  rctext* detach()
-  {
-    if(n==1)
-      return this;
-    rctext* t=new rctext(size, s);
-    n--;
-    return t;
-  };
-private:
-  rctext(const rctext&);
-  rctext& operator=(const rctext&);
+struct rcstring::rctext {
+    char* s;
+    unsigned int size;
+    unsigned int n;
+
+    rctext(unsigned int nsize, const char* p)
+    {
+        n = 1;
+        size = nsize;
+        s = new char[size + 1];
+        strncpy(s, p, size);
+        s[size] = '\0';
+    };
+    ~rctext()
+    {
+        delete[] s;
+    };
+    rctext* detach()
+    {
+        if (n == 1)
+            return this;
+        rctext* t = new rctext(size, s);
+        n--;
+        return t;
+    };
+
+  private:
+    rctext(const rctext&);
+    rctext& operator=(const rctext&);
 };
  
-class rcstring::Cref
-{
-  friend class rcstring;
-  rcstring& s;
-  int i;
-  Cref (rcstring& ss, unsigned int ii): s(ss), i(ii) {};
-public:
-  operator char() const
-  {
-    cout << "operator char() const"<<endl;
-    return s.read(i);
-  }
-  rcstring::Cref& operator = (char c)
-  {
-    cout << "void operator = (char c)"<<endl;
-    s.write(i,c);
-    return *this;
-  }
-  rcstring::Cref& operator = (const Cref& ref)
-  {
-    return operator= ((char)ref);
-  }
+class rcstring::Cref {
+    friend class rcstring;
+    rcstring& s;
+    int i;
+    Cref(rcstring& ss, unsigned int ii) : s(ss), i(ii){};
+
+  public:
+    operator char() const
+    {
+        cout << "operator char() const" << endl;
+        return s.read(i);
+    }
+    rcstring::Cref& operator=(char c)
+    {
+        cout << "void operator = (char c)" << endl;
+        s.write(i, c);
+        return *this;
+    }
+    rcstring::Cref& operator=(const Cref& ref)
+    {
+        return operator=((char)ref);
+    }
 };
 inline rcstring::rcstring()
-  {
-    data = new rctext(0,"");
-  }
+{
+    data = new rctext(0, "");
+}
  
 inline rcstring::rcstring(const rcstring& x)
-  {
+{
     x.data->n++;
-    data=x.data;
-  }
+    data = x.data;
+}
 inline rcstring::~rcstring()
 {
-  if(--data->n==0)
-    delete data;
+    if (--data->n == 0)
+        delete data;
 }
  
-rcstring& rcstring::operator=(const rcstring & x)
+rcstring& rcstring::operator=(const rcstring& x)
 {
-  x.data->n++;
-  if(--data->n == 0)
-    delete data;
-  data=x.data;
-  return *this;
+    x.data->n++;
+    if (--data->n == 0)
+        delete data;
+    data = x.data;
+    return *this;
 }
  
 rcstring::rcstring(const char* s)
 {
- data=new rctext(strlen(s),s);
+    data = new rctext(strlen(s), s);
 }
  
-ostream& operator << (ostream& o, const rcstring& s)
+ostream& operator<<(ostream& o, const rcstring& s)
 {
-  return o<<s.data->s;
+    return o << s.data->s;
 }
  
-rcstring& rcstring::operator+=(const rcstring & s)
+rcstring& rcstring::operator+=(const rcstring& s)
 {
-unsigned int newsize=data->size+s.data->size;
-rctext *newdata=new rctext(newsize,data->s);
-strcat(newdata->s,s.data->s);
-if(--data->n==0)
-  delete data;
-data = newdata;
-return *this;
+    unsigned int newsize = data->size + s.data->size;
+    rctext* newdata = new rctext(newsize, data->s);
+    strcat(newdata->s, s.data->s);
+    if (--data->n == 0)
+        delete data;
+    data = newdata;
+    return *this;
 }
  
-rcstring rcstring::operator+(const rcstring & s) const
+rcstring rcstring::operator+(const rcstring& s) const
 {
-  return rcstring(*this)+=s;
+    return rcstring(*this) += s;
 }
  
-inline void rcstring::check (unsigned int i) const
+inline void rcstring::check(unsigned int i) const
 {
-if(data->size<=i)
-  throw Range();
+    if (data->size <= i)
+        throw Range();
 }
 inline char rcstring::read(unsigned int i) const
 {
- return data->s[i];
+    return data->s[i];
 }
 inline void rcstring::write(unsigned int i, char c)
 {
-  data = data->detach();
-  data->s[i] = c;
+    data = data->detach();
+    data->s[i] = c;
 }
  
 char rcstring::operator[](unsigned int i) const
 {
-  cout << "char rcstring::operator[](unsigned int i) const"<<endl;
-  check(i);
-  return data->s[i];
+    cout << "char rcstring::operator[](unsigned int i) const" << endl;
+    check(i);
+    return data->s[i];
 }
  
 rcstring::Cref rcstring::operator[](unsigned int i)
 {
-  cout << "Cref rcstring::operator[](unsigned int i)"<<endl;
-  check(i);
-  return Cref(*this,i);
+    cout << "Cref rcstring::operator[](unsigned int i)" << endl;
+    check(i);
+    return Cref(*this, i);
 }
  
-
 #endif /* __RCSTRING_H__ */
 #ifndef __RCSTRING_H__
 #define __RCSTRING_H__
-#include <string.h>
-#include <stdio.h>
-#include <malloc.h>
 #include <iostream>
+#include <malloc.h>
+#include <stdio.h>
+#include <string.h>
 using namespace std;
  
-class rcstring{
-  struct rctext;
-  rctext* data;
-public:
-class Range{};
-class Cref;
-rcstring();
-rcstring(const char*);
-rcstring(const rcstring&);
-~rcstring();
-rcstring& operator=(const rcstring&);
-rcstring& operator+=(const rcstring &);
-rcstring operator+(const rcstring &) const;
-friend ostream& operator<<(ostream&, const rcstring&);
-void check (unsigned int i) const;
-char read(unsigned int i) const;
-void write(unsigned int i, char c);
-char operator[](unsigned int i) const;
-Cref operator[](unsigned int i);
-unsigned int getRefCount();
+class rcstring {
+    struct rctext;
+    rctext* data;
+
+  public:
+    class Range {};
+    class Cref;
+    rcstring();
+    rcstring(const char*);
+    rcstring(const rcstring&);
+    ~rcstring();
+    rcstring& operator=(const rcstring&);
+    rcstring& operator+=(const rcstring&);
+    rcstring operator+(const rcstring&) const;
+    friend ostream& operator<<(ostream&, const rcstring&);
+    void check(unsigned int i) const;
+    char read(unsigned int i) const;
+    void write(unsigned int i, char c);
+    char operator[](unsigned int i) const;
+    Cref operator[](unsigned int i);
+    unsigned int getRefCount();
 };
  
-struct rcstring::rctext
-{
-  char* s;
-  unsigned int size;
-  unsigned int n;
-
-  rctext(unsigned int nsize, const char* p)
-  {
-    n=1;
-    size=nsize;
-    s=new char[size+1];
-    strncpy(s,p,size);
-    s[size]='\0';
-  };
-  ~rctext()
-  {
-    delete [] s;
-  };
-  rctext* detach()
-  {
-    if(n==1)
-      return this;
-    rctext* t=new rctext(size, s);
-    n--;
-    return t;
-  };
-private:
-  rctext(const rctext&);
-  rctext& operator=(const rctext&);
+struct rcstring::rctext {
+    char* s;
+    unsigned int size;
+    unsigned int n;
+
+    rctext(unsigned int nsize, const char* p)
+    {
+        n = 1;
+        size = nsize;
+        s = new char[size + 1];
+        strncpy(s, p, size);
+        s[size] = '\0';
+    };
+    ~rctext()
+    {
+        delete[] s;
+    };
+    rctext* detach()
+    {
+        if (n == 1)
+            return this;
+        rctext* t = new rctext(size, s);
+        n--;
+        return t;
+    };
+
+  private:
+    rctext(const rctext&);
+    rctext& operator=(const rctext&);
 };
  
-class rcstring::Cref
-{
-  friend class rcstring;
-  rcstring& s;
-  int i;
-  Cref (rcstring& ss, unsigned int ii): s(ss), i(ii) {};
-public:
-  operator char() const
-  {
-    cout << "operator char() const"<<endl;
-    return s.read(i);
-  }
-  rcstring::Cref& operator = (char c)
-  {
-    cout << "void operator = (char c)"<<endl;
-    s.write(i,c);
-    return *this;
-  };
-  rcstring::Cref& operator = (const Cref& ref)
-  {
-    return operator= ((char)ref);
-  };
+class rcstring::Cref {
+    friend class rcstring;
+    rcstring& s;
+    int i;
+    Cref(rcstring& ss, unsigned int ii) : s(ss), i(ii){};
+
+  public:
+    operator char() const
+    {
+        cout << "operator char() const" << endl;
+        return s.read(i);
+    }
+    rcstring::Cref& operator=(char c)
+    {
+        cout << "void operator = (char c)" << endl;
+        s.write(i, c);
+        return *this;
+    };
+    rcstring::Cref& operator=(const Cref& ref)
+    {
+        return operator=((char)ref);
+    };
 };
  
 inline rcstring::rcstring()
-  {
-    data = new rctext(0,"");
-  }
+{
+    data = new rctext(0, "");
+}
  
 inline rcstring::rcstring(const rcstring& x)
-  {
+{
     x.data->n++;
-    data=x.data;
-  }
+    data = x.data;
+}
 inline rcstring::~rcstring()
 {
-  if(--data->n==0)
-    delete data;
+    if (--data->n == 0)
+        delete data;
 }
  
-rcstring& rcstring::operator=(const rcstring & x)
+rcstring& rcstring::operator=(const rcstring& x)
 {
-  x.data->n++;
-  if(--data->n == 0)
-    delete data;
-  data=x.data;
-  return *this;
+    x.data->n++;
+    if (--data->n == 0)
+        delete data;
+    data = x.data;
+    return *this;
 }
  
 rcstring::rcstring(const char* s)
 {
- data=new rctext(strlen(s),s);
+    data = new rctext(strlen(s), s);
 }
  
-ostream& operator << (ostream& o, const rcstring& s)
+ostream& operator<<(ostream& o, const rcstring& s)
 {
-  return o<<s.data->s;
+    return o << s.data->s;
 }
  
-rcstring& rcstring::operator+=(const rcstring & s)
+rcstring& rcstring::operator+=(const rcstring& s)
 {
-int newsize=data->size+s.data->size;
-rctext *newdata=new rctext(newsize,data->s);
-strcat(newdata->s,s.data->s);
-if(--data->n==0)
-  delete data;
-data = newdata;
-return *this;
+    int newsize = data->size + s.data->size;
+    rctext* newdata = new rctext(newsize, data->s);
+    strcat(newdata->s, s.data->s);
+    if (--data->n == 0)
+        delete data;
+    data = newdata;
+    return *this;
 }
  
-rcstring rcstring::operator+(const rcstring & s) const
+rcstring rcstring::operator+(const rcstring& s) const
 {
-  return rcstring(*this)+=s;
+    return rcstring(*this) += s;
 }
  
-inline void rcstring::check (unsigned int i) const
+inline void rcstring::check(unsigned int i) const
 {
-if(data->size<=i)
-  throw Range();
+    if (data->size <= i)
+        throw Range();
 }
 inline char rcstring::read(unsigned int i) const
 {
- return data->s[i];
+    return data->s[i];
 }
 inline void rcstring::write(unsigned int i, char c)
 {
-  data = data->detach();
-  data->s[i] = c;
+    data = data->detach();
+    data->s[i] = c;
 }
  
 char rcstring::operator[](unsigned int i) const
 {
-  cout << "char rcstring::operator[](unsigned int i) const"<<endl;
-  check(i);
-  return data->s[i];
+    cout << "char rcstring::operator[](unsigned int i) const" << endl;
+    check(i);
+    return data->s[i];
 }
  
 rcstring::Cref rcstring::operator[](unsigned int i)
 {
-  cout << "Cref rcstring::operator[](unsigned int i)"<<endl;
-  check(i);
-  return Cref(*this,i);
+    cout << "Cref rcstring::operator[](unsigned int i)" << endl;
+    check(i);
+    return Cref(*this, i);
 }
  
-
 unsigned int rcstring::getRefCount()
 {
-  return data->n;
+    return data->n;
 }
  
-
 #endif /* __RCSTRING_H__ */
-#include <stdio.h>
 #include <pthread.h>
+#include <stdio.h>
  
-
-void *
-thread1 (void *p)
+void* thread1(void* p)
 {
-  int *pp = (int *) p;
-  printf ("Parameter of thread1: %d\n", *pp);
-  *pp = 1;
-  for (unsigned int i = 0; i < 100000; i++)
-    printf ("Hello from thread 1\n");
-  pthread_exit (p);
+    int* pp = (int*)p;
+    printf("Parameter of thread1: %d\n", *pp);
+    *pp = 1;
+    for (unsigned int i = 0; i < 100000; i++)
+        printf("Hello from thread 1\n");
+    pthread_exit(p);
 }
  
-void *
-thread2 (void *p)
+void* thread2(void* p)
 {
-  int *pp = (int *) p;
-  printf ("Parameter of thread2: %d\n", *pp);
-  *pp = 2;
-  for (unsigned int i = 0; i < 100000; i++)
-    printf ("Hello from thread 2\n");
-  pthread_exit (p);
+    int* pp = (int*)p;
+    printf("Parameter of thread2: %d\n", *pp);
+    *pp = 2;
+    for (unsigned int i = 0; i < 100000; i++)
+        printf("Hello from thread 2\n");
+    pthread_exit(p);
 }
  
-
-int
-main ()
+int main()
 {
-  pthread_t t1;
-  pthread_t t2;
-  int *retval1;
-  int *retval2;
-  int r1 = 10, r2 = 11;
-
-
-  pthread_create (&t1, NULL, thread1, &r1);
-  pthread_create (&t2, NULL, thread2, &r2);
+    pthread_t t1;
+    pthread_t t2;
+    int* retval1;
+    int* retval2;
+    int r1 = 10, r2 = 11;
  
-  pthread_join (t1, (void **) &retval1);
-  pthread_join (t2, (void **) &retval2);
+    pthread_create(&t1, NULL, thread1, &r1);
+    pthread_create(&t2, NULL, thread2, &r2);
  
-  printf ("%d\n", *retval1);
-  printf ("%d\n", *retval2);
+    pthread_join(t1, (void**)&retval1);
+    pthread_join(t2, (void**)&retval2);
  
+    printf("%d\n", *retval1);
+    printf("%d\n", *retval2);
 }