#include <stdio.h>

void func(unsigned int a)
{
	int b = -20;
	printf("(unsigned int)b = %u\n",(unsigned int)b); // <span style="font-family: Arial, Helvetica, sans-serif;">4294967276 , 因为|b| + (unsigned int)b = 2^32,所以(unsigned int) b = 2^32 - |b|</span>

	int m = a + b;
	printf("%d\n",m);
	printf("%u\n",a+b);

	if (a + b > 0)
		printf(">0\n");
	else if (a + b < 0)
		printf("<0\n");
	else
		printf("=0\n");
}

int main()
{
	func(20); // 4294967276 + 20 = 4294967276,按照无符号数算，无符号32位最大值为2^32-1，即4294967275，这里循环回绕到0
	func(18); // 
	func(21);
	return 0;
}

=0
>0
>0

1. CSDN里面有价值的讨论帖

#include <iostream>
using namespace std;

class CA
{
private:
	int *p;
public:
	CA()
	{
		p = new int;
	}
};


CA func(CA c)
{
	CA a;
	a = c; //引发内存悬挂，原来a.p指向的那片内存，成为没有指针指向的内存
	
	return a;
}

int main()
{
	CA c;
	func(c);
	return 0;
}

#include <iostream>
using namespace std;

class CA
{
private:
	int *p;
public:
	CA()
	{
		p = new int;
	}
	//拷贝构造函数
	CA(const CA&);
	//赋值操作符重载
	CA& operator=(const CA &example);
};

//拷贝构造函数的实现
CA::CA(const CA& example)
{
	cout << "拷贝构造函数" <<endl;
	p = new int;
	*p = *example.p;
}

//赋值操作符重载的定义
CA& CA::operator=(const CA &example)
{
	int *temp = new int;
	*temp = *example.p; //复制指针指向的内容
	delete p; //释放原指针指向的内存空间
	p = temp; //建立新的指向
	return *this;
}


CA func(CA c)
{
	CA a;
	a = c; //引发内存悬挂，原来a.p指向的那片内存，成为没有指针指向的内存
	
	return a;
}

int main()
{
	CA c;
	CA d = func(c);
	return 0;
}

#include <iostream>
using namespace std;

class GlobalClass
{
private:
    int m_value;
    static GlobalClass *s_instance; // key1:定义一个静态变量
    GlobalClass(int v = 0) //key2：构造函数要私有
    {
        m_value = v;
    }

public:
    int get_value()
    {
        return m_value;
    }
    void set_value(int v)
    {
        m_value = v;
    }

	// key4:静态成员函数，初始化静态成员变量s_instance
    static GlobalClass *instance() 
    {
        if (!s_instance)
          s_instance = new GlobalClass;
        return s_instance;
    }
};

// key3: 静态成员变量的初始化，在类的外部，类似于成员函数的定义
// Allocating and initializing GlobalClass's
// static data member.  The pointer is being
// allocated - not the object inself.
GlobalClass *GlobalClass::s_instance = NULL;

void foo(void)
{
	GlobalClass::instance()->set_value(1);
	cout << "foo: global_ptr is " << GlobalClass::instance()->get_value() << '\n';
}

void bar(void)
{
	GlobalClass::instance()->set_value(2);
	cout << "bar: global_ptr is " << GlobalClass::instance()->get_value() << '\n';
}

int main()
{
	cout << "main: global_ptr is " << GlobalClass::instance()->get_value() << '\n';
	foo();
	bar();

	return 0;
}

#include <iostream>
using namespace std;

class CA
{
private:
	int numa;
public:
	CA():numa(0){}
	CA(int a):numa(a){cout << "基类构造函数" << endl;}
	~CA(){cout << "基类析构函数" <<endl;}
};


class CB: public CA
{
private:
	int numb;
public:
	CB(int a,int b):CA(a),numb(b){ cout << "子类构造函数" <<endl;}
	~CB(){cout << "子类析构函数"<<endl;}
};



int main()
{
	CB b(3,4);
	return 0;
}