#include <stdio.h>

void Tst(int x)
{
printf("%d\n", x);
}

void (*FPtr)() = Tst;

int main()
{
FPtr();
}

int somefunc()
{
    int flags;
    do1();
    flags = get_and_disable_interrupts();
    if (do2())
    {
        restore_interrupts(flags);
        return 1;
    }
    do3();
    restore_interrupts(flags);
    return 2;
}

class InterruptHolder
{
    int m_Flags;
public:
    InterruptHolder() {m_Flags = get_and_disable_interrupts();}
    !InterruptHolder() {restore_interrupts(m_Flags);}    
}

int somefunc()
{
    do1();
    InterruptHolder holder;
    if (do2())
        return 1;
    do3();
    return 2;
}

int somefunc()
  {
    int result = 2;

    do1();

    __Disable_Intr
      {
        if ( do2() )
          result = 1;
        else
          do3();
      } 
        
    return result;
  }

{
  Guard x(guarded);
  а тут чего-то делаем
}

struct A { int a; };
struct B : A { int b; };

B func() { return B(); }
A a = func();

#include <stdio.h>

struct CS {};

struct Guard
  { 
    Guard(CS &x) { printf("A()\n"); }       
    ~Guard() { printf("~A()\n"); }       
  };

int main()
{
  CS cs;
  Guard a(CS);
  Guard b(cs);
  Guard с();
}

/* C */
struct Base { int base_data; };
struct Derived { struct Base base; int derived_data; };

#include <stdio.h>

#ifdef __cplusplus

// sizeof(A) == 8
class A
{
    int n;
    char c;
};

// sizeof(B) == 8
class B : A
{
    char d;
};

#else

/* sizeof(A) == 8 */
typedef struct
{
    int n;
    char c;
} A;

/* sizeof(B) == 12 */
typedef struct
{
    A a;
    char d;
} B;

#endif

int main()
{
    printf("sizeof(A) == %ld, sizeof(B) == %ld\n", sizeof(A), sizeof(B));
    return 0;
}

/* 
 * C++ output:
 * sizeof(A) == 8, sizeof(B) == 8
 *
 * C output:
 * sizeof(A) == 8, sizeof(B) == 12
 */

case class Point3D(x : Int, y : Int, z : Int)

class Point3D
{
   int x_,y_,z_;
public:
   Point3D(int x, int y, int z) : x_(x), y_(y), z_(z) {}
   Point3D(const Point3D &that) : x_(that.x_), y_(that.y_), z_(that.z_) {}

   int getX() { return x_;}
   int getY() { return y_;}
   int getZ() { return z_;}

//...
   boolean operator == 
   operator = 
   ...
}

C>case class Point3D(x : Int, y : Int, z : Int)
C>

struct Point3D
{
   int x_,y_,z_;
};

class Base {
  virtual void f() {}
  void g() {}
};
class Derived : Base
{
  virtual void f() {}
  void g() {}
}; 

Base* pb = new Derived;
pb->g();
pb->f();

int buildno;
__Auto_Unwind
  buildno = strtol(Str_Trim(Oj_Read_Line(File_Open("textfile","r")),0,10);

#define CALL_DESTRUCTOR(X) __noop  /* define for your compiler appropriately */

void foo()
{
    MyClass a;
    MyClass b;

    // ...

    CALL_DESTRUCTOR(b);  // must be in reverse order!
    CALL_DESTRUCTOR(a);
}