Hello

void set_p(int* p, int val)   { p = new int(val); }
void set_pr(int*& p, int val) { p = new int(val); }

int main(void)
{
    int *a;

    // set_p(a, 10);
    set_pr(a, 10);
    cout << *a << endl;    

    // ...

    return 0;
}

if (JSGlobalObject*& headObject = head()) {
        d()->prev = headObject;
        d()->next = headObject->d()->next;
        headObject->d()->next->d()->prev = this;
        headObject->d()->next = this;
} else {
        headObject = d()->next = d()->prev = this;
}

void* vptr() { return * reinterpret_cast<void**>(this); }

결국 vptr()을 통해서 해당 virtual function에 직접 access 가능 하다.

실제 사용은,

// ...
if (value.isCell() && (value.asCell()->vptr() == globaData.jsFunctionVPtr)
// ...
struct VPtrSet {
    VPtrSet();
    
    void* jsArrayVPtr;
    void* jsByteArrayVPtr;
    void* jsStringVPtr;
    void* jsFunctionVPtr;
};

요렇게 쓰인다.

// tunable parameters
template<size_t bytesPerWord> struct CellSize;

// cell size needs to be a power of two for certain optimizations in collector.cpp
template<> struct CellSize<sizeof(uint32_t)> { static const size_t m_value = 64; };
template<> struct CellSize<sizeof(uint64_t)> { static const size_t m_value = 64; };

const size_t MINIMUM_CELL_SIZE = CellSize<sizeof(void*)>::m_value;
const size_t CELL_ARRAY_LENGTH = (MINIMUM_CELL_SIZE / sizeof(double)) + \
	(MINIMUM_CELL_SIZE % sizeof(double) != 0 ? sizeof(double) : 0);
const size_t CELL_SIZE = CELL_ARRAY_LENGTH * sizeof(double);

#define COMPILE_ASSERT(exp, name) typedef int dummy##name [(exp) ? 1 : -1]
#define ASSERT_CLASS_FITS_IN_CELL(class) \
	COMPILE_ASSERT(sizeof(class) <= CELL_SIZE, class_fits_in_cell)

  
static inline unsigned int generic_hweight32(unsigned int w)
{
    unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555);
    res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
    res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F);
    res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF);
    return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF);
}

static inline unsigned int generic_hweight16(unsigned int w)
{
    unsigned int res = (w & 0x5555) + ((w >> 1) & 0x5555);
    res = (res & 0x3333) + ((res >> 2) & 0x3333);
    res = (res & 0x0F0F) + ((res >> 4) & 0x0F0F);
    return (res & 0x00FF) + ((res >> 8) & 0x00FF);
}

static inline unsigned int generic_hweight8(unsigned int w)
{
    unsigned int res = (w & 0x55) + ((w >> 1) & 0x55);
    res = (res & 0x33) + ((res >> 2) & 0x33);
    return (res & 0x0F) + ((res >> 4) & 0x0F);
}

static inline unsigned long generic_hweight64(__u64 w)
{
#if BITS_PER_LONG < 64
    return generic_hweight32((unsigned int)(w >> 32)) +
        generic_hweight32((unsigned int)w);
#else
    u64 res;
    res = (w & 0x5555555555555555ul) + ((w >> 1) & 0x5555555555555555ul);
    res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
    res = (res & 0x0F0F0F0F0F0F0F0Ful) + ((res >> 4) & 0x0F0F0F0F0F0F0F0Ful);
    res = (res & 0x00FF00FF00FF00FFul) + ((res >> 8) & 0x00FF00FF00FF00FFul);
    res = (res & 0x0000FFFF0000FFFFul) + ((res >> 16) & 0x0000FFFF0000FFFFul);
    return (res & 0x00000000FFFFFFFFul) + ((res >> 32) & 0x00000000FFFFFFFFul);
#endif
}

#define FOR_EACH_OPCODE_ID(macro) \
    macro(op_enter, 1) \
    macro(op_enter_with_activation, 2)	\
    macro(op_init_arguments, 1) \
    macro(op_create_arguments, 1) \
    macro(op_convert_this, 2) \
    \
    macro(op_new_object, 2) \
    macro(op_new_array, 4) \
    macro(op_new_regexp, 3) \
    macro(op_mov, 3) \
    \
    macro(op_end, 2)

#define OPCODE_ID_ENUM(opcode, length) opcode,
typedef enum { FOR_EACH_OPCODE_ID(OPCODE_ID_ENUM) } OpcodeID;
#undef OPCODE_ID_ENUM

const int numOpcodeIDs = op_end + 1;

#define OPCODE_ID_LENGTHS(id, length) const int id##_length = length;
FOR_EACH_OPCODE_ID(OPCODE_ID_LENGTHS);
#undef OPCODE_ID_LENGTHS
    
#define OPCODE_LENGTH(opcode) opcode##_length

#define OPCODE_ID_LENGTH_MAP(opcode, length) length,
const int opcodeLengths[numOpcodeIDs] = {FOR_EACH_OPCODE_ID(OPCODE_ID_LENGTH_MAP)};
#undef OPCODE_ID_LENGTH_MAP

typedef enum {
    op_enter,
    op_enter_with_activation,
    op_init_arguments,
    op_create_arguments,
    op_convert_this,
    op_new_object,
    op_new_array,
    op_new_regexp,
    op_mov,
    op_end,
} OpcodeID;


const int numOpcodeIDs = op_end + 1;


const int op_enter_length = 1;
const int op_enter_with_activation_length = 2;
const int op_init_arguments_length = 1;
const int op_create_arguments_length = 1;
const int op_convert_this_length = 2;
const int op_new_object_length = 2;
const int op_new_array_length = 4;
const int op_new_regexp_length = 3;
const int op_mov_length = 3;
const int op_end_length = 2;


const int opcodeLengths[numOpcodeIDs] = { 1, 2, 1, 1, 2, 2, 4, 3, 3, 2, };

class X
{
	// ...
	X(Sometype);	// constructor : create objects
	X(const X&);	// copy constructor
	X& operator=(const X&) // copy assignment : cleanup and copy
	~X()	// destructor : cleanup
};

  
#include <iostream>
using namespace std;

class Sample
{
public:
	Sample(int e);
	Sample(const Sample&);
	Sample& operator=(const Sample&);
	~Sample();

private:
	int _elem;
};

Sample::Sample(int e) : _elem(e)
{
	cout << "Constructor : " << this << endl;
}

Sample::Sample(const Sample& s)
{
	cout << "Copy constructor : " << this << endl;

	_elem = s._elem;
}

Sample& Sample::operator=(const Sample& s)
{
	cout << "Copy assignment : " << this << endl;

	_elem = s._elem;
	return *this;
}

Sample::~Sample()
{
	cout << "Destructor : " << this << endl;
}

Sample g(Sample s)
{
	return s;
}

int main(void)
{
	Sample s(1);
	s = g(s);
	return 0;
}

  
#include <iostream>
using namespace std;

class Command
{
public:
	virtual void Execute() = 0;
};

template <class Receiver>
class SimpleCommand : public Command
{
public:
	typedef void (Receiver::*Action) ();

	SimpleCommand(Receiver* r, Action a) : _receiver(r), _action(a) {}
	virtual void Execute();

private:
	Action _action;
	Receiver* _receiver;
};

template<class Receiver>
void SimpleCommand<Receiver>::Execute()
{
	(_receiver->*_action)();
}


class MyClass
{
public:
	MyClass() {}
	MyClass(const MyClass &) {}
	MyClass(const MyClass *) {}
	void MyAction() { cout << "MyClass Action\n"; }
};

int main(void)
{
	MyClass* receiver = new MyClass;
	Command* aCommand = new SimpleCommand<MyClass>(receiver, &MyClass::MyAction);
	aCommand->Execute();
}

_AFXWIN_INLINE HWND CWnd::GetSafeHwnd() const
	{ return this == NULL ? NULL : m_hWnd; }

#define offset(s, m) \
(size_t)&reinterpret_cast<const volatile char&>((((s *)0)->m));

class A
{
public:
	class X
	{
	public:
		void callAVtFunc();
	} m_x;

	virtual void VtFunc() { std::cout << "OK\n"; }
};

void A::X::callAVtFunc()
{
	A* a = ((A*)((char*)this - offsetof(A, m_x)));
	a->VtFunc();
}

int main(void)
{
	A a;
	a.m_x.callAVtFunc();

	return 0;
}

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);
}