class HaHa
{
	delegate void GlugGlug();
public:
	void Zomg()
	{
		dispatcher->Invoke(DispatcherPriority::Normal, gcnew GlugGlug(this, &HaHa::Pooper));
		dispatcher->Invoke(DispatcherPriority::Normal, gcnew GlugGlug(this, &HaHa::Pirate));
	}
	void Pooper() { }
	void Pirate() { }
}

class HaHa
{
	delegate void GlugGlug();
	GlugGlug^ glug;
	GlugGlug^ zomg;
public:
	HaHa()
	{
		glug = gcnew GlugGlug(this, &HaHa::Pooper);
		zomg = gcnew GlugGlug(this, &HaHa::Pirate);
	}
	void Zomg()
	{
		dispatcher->Invoke(DispatcherPriority::Normal, glug);
		dispatcher->Invoke(DispatcherPriority::Normal, zomg);
	}
	void Pooper() { }
	void Pirate() { }
}

public class Class
{
	delegate void InvokeEvent(EventArgs e);
	public event EventHandler Event;

	public Class()
	{
		ThreadPool.QueueUserWorkItem(new WaitCallback(Work));
	}

	void Work()
	{
		Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new InvokeEvent(OnEvent), new EventArgs());
	}

	protected void OnEvent(EventArgs e)
	{
		if (Event != null) Event(this, e);
	}
}

public class Class
{
	public event EventHandler Event;

	public Class()
	{
		ThreadPool.QueueUserWorkItem(new WaitCallback(Work));
	}

	void Work(object state)
	{
		OnEvent(new EventArgs());
	}

	protected void OnEvent(EventArgs e)
	{
		if (Event != null)
		{
			if (Thread.CurrentThread == Application.Current.Dispatcher.Thread)
			{
				Event(this, e);
			}
			else
			{
				Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new EventHandler(Event), this, e)
			}
		}
	}
}

using System.ComponentModel;

public class Zomg : INotifyPropertyChanged
{
	public event EventHandler Gloop;
	public event PropertyChangedEventHandler PropertyChanged;
	
	protected void OnGloop(EventArgs e)
	{
		if (Gloop != null) Gloop(this, e);
	}
	
	protected void OnPropertyChanged(PropertyChangedEventArgs e)
	{
		if (PropertyChanged != null) PropertyChanged(this, e);
	}
}

using namespace System::ComponentModel;

publc ref class Zomg : public INotifyPropertyChanged
{
public:
	event EventHandler^ Gloop;
	virtual event PropertyChangedEventHandler^ PropertyChanged; // virtual keywordu vajadzēja!
	
protected:
	virtual void OnGloop(EventArgs^ e)
	{
		Gloop(this, e);
	}
	
	virtual void OnPropertyChanged(PropertyChangedEventArgs^ e)
	{
		PropertyChanged(this, e);
	}
};

short a, b, c;
c = (a + b) / 2;
c = a / 2 + b / 2;
c = ((int)a + b) / 2;

a b c p
e f g q
i j k r
l m n s

Graph graph;
Node root = graph.add_node(); // koka sakne
Node i = root;
while (whatever)
{
	// staigājam pa grafu, izrēķinam, kur pievienot nākamo pēcteci
	i.create_child();
}
// izvadam koka vizualizāciju SVG formātā

Detected memory leaks!
Dumping objects -
{1871} normal block at 0x00F8DAF0, 52 bytes long.
Data: 1 0 01 00 00 00 03 00 00 00 13 00 00 00 31 00 30 00
{1869} normal block at 0x00F8D9A0, 24 bytes long.
Data: C8 D3 F8 00 1C DA F8 00 FC DA F8 00 CE CD CD CD
{1868} normal block at 0x00F8DA10, 52 bytes long.
Data: L e 01 00 00 00 04 00 00 00 13 00 00 00 4C 00 65 00
{1866} normal block at 0x00F8D8C0, 12 bytes long.
Data: L 4C D1 F8 00 00 00 00 00 00 D7 F8 00
{1865} normal block at 0x00F8D930, 52 bytes long.

A.h
#pragma once // ļauj failu iekļaut tikai vienreiz. ķipa #ifndef __A_H__ bla bla
#include "B.h"
class A
{
public:
    B b; // syntax error : missing ';' before identifier 'b'
};

B.h
#pragma once
#include "A.h" // ja šo rindu atkomentētu, kods nokompilētos
class B { };

main.cpp
#include "A.h"
int main()
{
    A a;
    return 0;
}

Risinājums

delete from table(deref(objekts).kolekcija) where column_value = 'whatever';

class Boo
{
public:
	Boo() : read_only_property(private_variable) { }
	const int& read_only_property;
private:
	int private_variable;
};

class Pudele
{
public:
	Tilpums tilpums;
	class Tilpums
	{
	public:
		int operator =(int value) { tilpums = value; }
		operator int() { return tilpums; }
	private:
		int tilpums;
	};
};