Hello

class IUnknown
{
public:
	virtual void QueryInterface() = 0;
	virtual void AddRef() = 0;
	virtual void Release() = 0;
};

class IDummy : public IUnknown
{
public:
	virtual void Fx() = 0;
};

class INondelegatingUnknown
{
public:
	virtual void NondelegatingQueryInterface() = 0;
	virtual void NondelegatingAddRef() = 0;
	virtual void NondelegatingRelease() = 0;
};

class C : public IDummy,
	      public INondelegatingUnknown
{
public:
	virtual void QueryInterface() { std::cout << "QueryInterface" << std::endl; }
	virtual void AddRef() { std::cout << "AddRef" << std::endl; }
	virtual void Release() { std::cout << "Release" << std::endl; }

	virtual void NondelegatingQueryInterface() 
                 { std::cout << "NondelegatingQueryInterface" << std::endl; }
	virtual void NondelegatingAddRef() 
                 { std::cout << "NondelegatingAddRef" << std::endl; }
	virtual void NondelegatingRelease() 
                 { std::cout << "NondelegatingRelease" << std::endl; }

	virtual void Fx() { std::cout << "Fx()" <<  std::endl; }

	C();

public:
	IUnknown* m_pI;
	void Go();
};

C::C()
{
	m_pI = reinterpret_cast<IUnknown*>
                   ( static_cast<INondelegatingUnknown*>(this) ); 
}

void C::Go()
{
	m_pI->QueryInterface();
}

int _tmain(void)
{
	C c;

	c.Go();

	return 0;
}

InsideComAggregation.zip

원문 : http://www.cs.rutgers.edu/LCSR-Computing/some-docs/emacs-chart.html

C-SP     set-mark-command  
C-q      quoted-insert
C-a      beginning-of-line   
C-b      backward-char  
C-r      isearch-backward
C-r RET  search-backward  
C-s      isearch-forward    
C-s RET  search-forward
C-c      exit-recursive-edit  
C-t      transpose-chars
C-d      delete-char   
C-u      universal-argument (M-num)
C-e      end-of-line   
C-v      scroll-up
C-f      forward-char   
C-w      kill-region
C-h      help-command   
C-x      Control-X-prefix
TAB      indent-for-tab-command  
C-y      yank
LFD      newline-and-indent  
C-z      suspend-emacs
C-k      kill-line   
ESC      ESC-prefix
C-l      recenter   
C-]      abort-recursive-edit
RET      newline   
C-_      undo
C-n      next-line   
SPC .. ~        self-insert-command
C-o      open-line   
DEL      delete-backward-char
C-p      previous-line

C-h v    describe-variable  
C-h d    describe-function
C-h w    where-is   
C-h k    describe-key
C-h t    help-with-tutorial  
C-h c    describe-key-briefly
C-h s    describe-syntax  
C-h b    describe-bindings
C-h n    view-emacs-news  
C-h a    command-apropos
C-h C-n  view-emacs-news  
C-h C-d  describe-distribution
C-h m    describe-mode   
C-h C-c  describe-copying
C-h l    view-lossage   
C-h ?    help-for-help
C-h i    info    
C-h C-h  help-for-help
C-h f    describe-function

C-x C-a  add-mode-abbrev  
C-x 5    split-window-horizontally
C-x C-b  list-buffers   
C-x ;    set-comment-column
C-x C-c  save-buffers-kill-emacs 
C-x <    scroll-left
C-x C-d  list-directory   
C-x =    what-cursor-position
C-x C-e  eval-last-sexp   
C-x >    scroll-right
C-x C-f  find-file   
C-x [    backward-page
C-x C-h  inverse-add-mode-abbrev 
C-x ]    forward-page
C-x TAB  indent-rigidly   
C-x ^    enlarge-window
C-x C-l  downcase-region  
C-x `    next-error
C-x C-n  set-goal-column  
C-x a    append-to-buffer
C-x C-o  delete-blank-lines  
C-x b    switch-to-buffer
C-x C-p  mark-page   
C-x d    dired
C-x C-q  toggle-read-only  
C-x e    call-last-kbd-macro
C-x C-r  find-file-read-only  
C-x f    set-fill-column
C-x C-s  save-buffer   
C-x g    insert-register
C-x C-t  transpose-lines  
C-x h    mark-whole-buffer
C-x C-u  upcase-region   
C-x i    insert-file
C-x C-v  find-alternate-file  
C-x j    register-to-dot
C-x C-w  write-file   
C-x k    kill-buffer
C-x C-x  exchange-dot-and-mark  
C-x l    count-lines-page
C-x C-z  suspend-emacs   
C-x m    mail
C-x ESC  repeat-complex-command  
C-x n    narrow-to-region
C-x $    set-selective-display  
C-x o    other-window
C-x (    start-kbd-macro  
C-x p    narrow-to-page
C-x )    end-kbd-macro   
C-x q    kbd-macro-query
C-x +    add-global-abbrev  
C-x r    copy-rectangle-to-register
C-x -    inverse-add-global-abbrev 
C-x s    save-some-buffers
C-x .    set-fill-prefix  
C-x u    advertised-undo
C-x /    dot-to-register  
C-x w    widen
C-x 0    delete-window   
C-x x    copy-to-register
C-x 1    delete-other-windows  
C-x {    shrink-window-horizontally
C-x }    enlarge-window-horizontally
C-x 2    split-window-vertically 
C-x 4    ctl-x-4-prefix   
C-x DEL  backward-kill-sentence

ESC C-SP mark-sexp   
ESC =    count-lines-region
ESC C-a  beginning-of-defun  
ESC >    end-of-buffer
ESC C-b  backward-sexp   
ESC @    mark-word
ESC C-c  exit-recursive-edit  
ESC O    ??
ESC C-d  down-list   
ESC [    backward-paragraph
ESC C-e  end-of-defun   
ESC \    delete-horizontal-space
ESC C-f  forward-sexp   
ESC ]    forward-paragraph
ESC C-h  mark-defun   
ESC ^    delete-indentation
ESC LFD  indent-new-comment-line 
ESC a    backward-sentence
ESC C-k  kill-sexp   
ESC b    backward-word
ESC C-n  forward-list   
ESC c    capitalize-word
ESC C-o  split-line   
ESC d    kill-word
ESC C-p  backward-list   
ESC e    forward-sentence
ESC C-s  isearch-forward-regexp   
ESC C-r  isearch-backward-regexp   
ESC f    forward-word
ESC C-t  transpose-sexps  
ESC g    fill-region
ESC C-u  backward-up-list  
ESC h    mark-paragraph
ESC C-v  scroll-other-window  
ESC i    tab-to-tab-stop
ESC C-w  append-next-kill  
ESC j    indent-new-comment-line
ESC ESC  ??    
ESC k    kill-sentence
ESC C-\  indent-region   
ESC l    downcase-word
ESC SPC  just-one-space   
ESC m    back-to-indentation
ESC !    shell-command   
ESC q    fill-paragraph
ESC $    spell-word   
ESC r    move-to-window-line
ESC %    query-replace    
ESC C-%  query-replace-regexp    
ESC t    transpose-words
ESC '    abbrev-prefix-mark  
ESC u    upcase-word
ESC (    insert-parentheses  
ESC v    scroll-down
ESC )    move-past-close-and-reindent 
ESC w    copy-region-as-kill
ESC ,    tags-loop-continue  
ESC x    execute-extended-command
ESC -    negative-argument  
ESC y    yank-pop
ESC .    find-tag   
ESC z    zap-to-char
ESC 0 .. ESC 9  digit-argument  
ESC |    shell-command-on-region
ESC ;    indent-for-comment  
ESC ~    not-modified
ESC <    beginning-of-buffer  
ESC DEL  backward-kill-word

C-x 4 C-f       find-file-other-window 
C-x 4 d  dired-other-window
C-x 4 .  find-tag-other-window  
C-x 4 f  find-file-other-window
C-x 4 b  pop-to-buffer   
C-x 4 m  mail-other-window

C-x r m  set-book-mark
C-x r l  list-bookmarks
C-x r b  bookmark-jump           

int main(void)
{
	...
	char a[3] = {'a', 'b', 'c'}

	char *start = &a[0];
	char *end = &a[4];

	while (p != end) cout << *p++;
	...
	return 0;
}

 
void f()
{
	int v1[10];
	int v2[10];

	int i1 = &v1[5] - &v1[3]; // i1 = 2
	int i2 = &v1[5] - &v2[3]; // result undefined

	int *p1 = v2 + 2; // p1 = &v2[2]
	int *p2 = v2 - 2; // result undefined
	int *p3 = &v2[4] - 2; // p3 = &v2[2]
}

  
int main(void)
{
void f()
{
	char s[] = "Grom";
	
	const char* pc = s; // pointer to constant. *PC가 상수
	char* const cp = s; // constant pointer. CP가 상수
	const char* const cpc = s; // constant pointer to constant. *CPC, CPC 모두 상수
}

 
char *const cp; // const pointer to char
const char* pc; // pointer to const char
char const* pc; // pointer to const char

  
void f(keyword key)
{
	switch (key) {
	case ASM:
		// do something
		break;
	case BREAK:
		// do something
		break;
	}
}

  
#include <limits>
// ...
numeric_limits<float>::max();
// ...

  
int x;

void f2()
{
	int x = 1; // hide global x
	::x = 2; // assign to global x
	x = 2; // assign to local x
	// ...
}

 
void f()
{
	int a = 1;
	const int c = 2;
	const int* p1 = &c; 	// ok
	const int* p2 = &a; 	// ok
	int* p3 = &c; 		// error
}

  
void f()
{
	void* pv = pi; 	// ok: implicit conversion of int* to void*
	*pv; 			// error : can't dereference void*
	pv++; 		// error : cna't increment void*
	
	int* pv2 = static_cast<int*>(pv); 		// explicit conversion back to int*
	
	double* pd1 = pv; 					// error
	double* pd2 = pi; 					// error
	double* pd3 = static_cast<double*>(pv); 	// unsafe
}

  
struct Link {
	Link* prev;	// ok
	Link* next;	// ok
	Link member;	// error: recursive definition
}

 
class Stack {
public:
	class Underflow{};
	class Overflow{};

	 // =0은 상속받은 클래스는 이 함수들을 다시 정의해야함을 의미
	virtual void push(char c) = 0;
	virtual void pop() = 0;
}

class Array_stack : public Stack {
	char* p;
	int max_size;
	int top;
public:
	Array_stack(int s);
	~Array_stack();

	void push(char c);
	char pop();
};

class List_stack : public Stack {
	list<char> lc;
public:
	List_stack() {}
	void push(char c) { lc.push_front(c); }
	char pop();
}

char List_stack::pop()
{
	char x = lc.front();
	lc.pop_front();

	return x;
}



void f(Stack& s_ref)
{
	s_ref.push('c');
	if (s_ref.pop() != 'c') throw Bad_pop();
}

void g()
{
	Array_stack as(200);
	f(as);

void h()
{
	List_stack ls;
	f(ls);
}