//声明
enum wT{
    Monday,
    Tuseday,
    Wednesday,
    Thursday,
    Firday,
    Saturday,
    Sunday
};

//定义
wT weekday;

#include <iostream>
using namespace std;
int main()
{
	enum wT{Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday}; // 声明wT类型
	wT weekday;
	weekday = Monday;
	weekday = Tuesday;
	//weekday = 1;             // 错误 不能直接给int值，只能赋值成wT定义好的类型值
    //可以写成weekday = wT(1),但是涉及类型转换的写法不推荐
	cout << weekday << endl;
	//Monday = 0;             // 错误 类型值不能做左值，不是有存储空间的变量
	int a = Wednesday;
	cout << a << endl;

    return 0;
}

struct Student
{
    char name[6];
    int age;
    Score s;
};

union Score
{
    double sc;
    char level;
};

#include <string.h>
#include <iostream>
using namespace std;

int main()
{
	union Score 
	{
		double ds;    //8字节
		char level;   //1字节
	};
	struct Student
	{
		char name[6];      //6字节                           
		int age;           //32位环境 4字节
		Score s;               
	};

	cout << sizeof(Score) << endl;      // 8
	
	Student s1;
	strcpy_s(s1.name, "lili");
	s1.age = 16;
	s1.s.ds = 95.5;
	s1.s.level = 'A';

	cout << sizeof(Student) << endl;    // 24     


    return 0;
}

struct s1
{
    char x;
    int z;
    short y;
};

sizeof(s1) = 12;

struct s2
{
    char x;
    short y;
    int z;
};

sizeof(s2) = 8;

#include <iostream>
using namespace std;

bool isLeapYear(unsigned int year)
{
	// 双分支if
	//if ( (year % 400 == 0) ||  (year%4==0 && year%100 != 0) )
    //这里有个if的优化，因为||操作符，第一个条件满足不看后面的，&&操作符第一个条件不满足不看后面的
    //所以按下面的方式效率更高，因为涉及命中率问题，被4整除的概率更高
	if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
	{
		return true;
	}
	else
	{
		return false;
	}
}

int main()
{
    // 是否是闰年
	cout << isLeapYear(2000) << endl;
	cout << isLeapYear(2020) << endl;
	cout << isLeapYear(2021) << endl;
    return 0;
}

#include <iostream>
using namespace std;

int main()
{
	// b是否是a的倍数
	int a = 0;
	int b = 4;
    //短路运算，除数不能为0
	if ((a != 0) && b % a == 0)
	{
		cout << "b是a的倍数" << endl;
	}
	else
	{
		cout << "b不是a的倍数" << endl;
	}

	return 0;
}

#include <iostream>
using namespace std;

typedef enum __COLOR
{
	RED,
	GREEN,
	BLUE,
	UNKOWN
}COLOR;

int main()
{
	// 多分支条件的if
	// if, else if, else
	COLOR color0;
	color0 = BLUE;
	int c0 = 0;
	if (color0 == RED) {
		//cout << "red" << endl; 
		c0 += 1;
	}
	else if (color0 == GREEN) {
		//cout << "green" << endl; 
		c0 += 2;
	}
	else if (color0 == BLUE) {
		//cout << "blue" << endl;
		c0 += 3;
	}
	else {
		//cout << "unknown color" << endl; 
		c0 += 0;
	}

	// 多分支条件的switch
	// switch,case,default
	COLOR color1;
	color1 = GREEN;
	int c1 = 0;
	switch (color1)
	{
	case RED:
	{
		//cout << "red" << endl;
		c1 += 1;
		break;
	}
	case GREEN:
	{
		//cout << "green" << endl; 
		c1 += 2;
		break;
	}
	case BLUE:
	{
		//cout << "blue" << endl;
		c1 += 3;
		break;
	}
	default:
	{
		//cout << "unknown color" << endl;
		c1 += 0;
		break;
	}
	}


	return 0;
}

//计算1 + 2 + …… + 99 + 100的和

#include <iostream>
using namespace std;
int main()
{   // TODO: 1+2+3+4...+100
	// while语句
	int sum = 0;
	int index = 1;
	while (index <= 100)
	{
		sum += index;
		index += 1;
	}
	cout << sum << endl;

	// for语句
	index = 1;
	sum = 0;
	for (index = 1; index <= 100; ++index)
	{
		sum += index;
	}
	cout << sum << endl;

	// do-while语句
	sum = 0;
	index = 1;
	do
	{
		sum += index;
		index += 1;
	} while (index <= 100);
	cout << sum << endl;

	return 0;
}

#include <iostream>
using namespace std;
#include <math.h>

int main()
{
	// aabb的完全平方数

	//方法一：一个显而易见的方法
	int n = 0;
	double m = 0;
	for (size_t a = 1; a < 10; a++)
	{// for1
		for (size_t b = 0; b < 10; b++)
		{// for 2
			n = a * 1100 + b * 11; //aabb
			//求平方根，看是否是整数
			m = sqrt(n);          
			if (m - int(m) < 0.00000001)  //当差值小于一个极小值即可，这个值和浮点数的精度有关
			{
				cout << n << endl;
			}
		}// for 2
	}// for1


	//方法二：逆向思维
	//先保证是平方根，再看是否是aabb类型
	//这样做第一不需要双层循环，第二避免了开平方根造成的精度丢失和低速运算
	int high, low;

	//不需要从1开始，31*31=961，32*32=1024
	for (size_t index = 31; ; index++)
	{
		n = index * index; //n就是我们要构造的完全平方数
		if (n < 1000)
			continue;   // 继续下一次循环
		if (n > 9999)
			break;        // 退出循环
		high = n / 100;   // 4567/100 = 45
		low = n % 100;   // 4567%100 = 67
		if ((high / 10 == high % 10) && (low / 10 == low % 10))   // 判断aa， bb
		{
			cout << n << endl;
		}
	}

	return 0;
}

#include <iostream>
using namespace std;
#include <math.h>

int test(int a)
{
	return a;
}

int test(double a)
{
	return int(a);
}

int test(int a, double b)
{
	return a + b;
}

int main()
{
	int result = test(1);
	result = test(2.0);
	result = test(1, 2.0);

	return 0;
}

#include <iostream>

int test(int a)
{
	return a;
}

int test(double a)
{
	return int(a);
}

int test(int a, double b)
{
	return a + b;
}
int main()
{
	int(*p)(int);  //定义一个指针p，表示参数是int，返回值是int的一个函数
	p = test;   //指针变量赋值，此时虽然有三个同名函数，但明确指向的是参数为int的函数
	int result = (*p)(1); //函数指针的使用，此时*p是间接引用


	return 0;
}

#include <iostream>
using namespace std;

int MaxValue(int x, int y)
{
	return (x > y) ? x : y;
}

int MinValue(int x, int y)
{
	return (x < y) ? x : y;
}

int Add(int x, int y)
{
	return x + y;
}

bool ProcessNum(int x, int y, int(*p)(int a, int b)) //参数中有函数指针
{
	cout << p(x, y) << endl;
	return true;
}

int main()
{
	int x = 10, y = 20;

	//直接用函数名做参数，只要保证函数的参数列表是两个int，返回值是int就可以
	ProcessNum(x, y, MaxValue);
	ProcessNum(x, y, MinValue);
	ProcessNum(x, y, Add);

	return 0;
}

#include <iostream>
using namespace std;

int test(int a)
{
	return a;
}

namespace AA
{
	int test(int a)
	{
		return a + 1;
	}
}

int main()
{
	cout << test(1) << endl;

	cout << AA::test(1) << endl;

	return 0;
}

inline int MaxValue(int x,int y)
{
	return (x > y) ? x : y;
}

int main()
{
	int a = 1;
	float b = 3.14;
	//指针定义
	int* c = &a;  //c存储a的内存地址
	float* d = &b;

	cout << c << endl;   //输出a变量的地址

	//间接访问
	cout << (*c) << endl; //等同于cout<<a<<endl;
	cout << (*d) << endl;//等同于cout<<b<<endl;

	return 0;
}

int main()
{
	//两种字符串表示
	char strHello[] = { "hello" };
	const char* pStrHello = "hello";

	pStrHello = strHello;   //正确，指针变量的值可以改变
	strHello = pStrHello;   //错误，数组变量的值不允许改变
	return 0;
}

int i = 4;
int* iP = &i;
cout<<(*iP)<<endl;

double d = 3.14;
double* dP =&d;
cout<<(*dP)<<endl;

int* a[4];

int c[4] = {1,2,3,4};
int(*b)[4];
b = &c;  //数组的个数一定要匹配
//注意，[]的优先级比较高


for(unsigned int i = 0;i<4;i++)
{
	a[i] = &(c[i]);
}



cout<<*(a[0])<<endl;  //先取数组下标得到地址，然后做间接访问
cout<<(*b)[3]<<endl;  //b是指针，先间接访问取值得到数组，然后取数组下标

int main()
{
	char strHello[] = { "helloworld" };

	char const* pStr1 = "helloworld";  //修饰char，指针指向的地址可变，但是存储的区域中的内容不可变
	char* const pStr2 = "helloworld"; //修饰char*，指针指向的地址不可变。在最新的VS中编译不过，因为"helloworld"是常量，必须要用const指针
	char const* const pStr3 = "helloworld"; //地址和空间中的内容都不允许改变

	pStr1 = strHello;
	//pStr2 = strHello;   //错误，pStr2地址不可改
	//pStr3 = strHello;   //错误，pStr3地址不可改 

	//pStr1[1] = 'a';   //错误，存储区内的char不可改变
	pStr2[1] = 'a';
	//pStr3[1] = 'a';   //错误，存储区内的char不可变

	return 0;
}

int a = 123;
int* b = &a;
int** c = &b;

int* a;
*a = 12;//错误！！

int* a = NULL;

char ch = 'a';
char* cP = &ch;

int main()
{
    char ch = 'a';
	//&操作符
	//&ch = 97;      //错误，&ch左值不合法
	char* cp = &ch; //&ch右值
	//&cp = 97;		//错误，&左值不合法
	char** cpp = &cp;		//&cp右值


	//*操作符
	*cp = 'a';				//*cp左值取变量ch的位置
	char ch2 = *cp;			//*cp右值取变量ch存储的值
	//*cp + 1 = 'a';			//错误，*cp+1左值不合法的位置
	ch2 = *cp + 1;			//*cp+1右值取到的字符做ASCII码+1操作
	*(cp + 1) = 'a';			//左值，语法上合法，访问到cp后面的位置，赋值为a.一定要保证这个位置是可以访问的，这种操作有风险
	ch2 = *(cp + 1);			//右值操作，取ch后面的位置的值
}

char* cp2 = ++cp;
//汇编代码：
mov		eax,dword ptr [cp]		//eax是寄存器，dwptr存储cp指针。把指针内容放置寄存器内
add		eax,1					//寄存器数据+1
mov		dword ptr [cp],eax		//把寄存器内容存回cp中
mov 	ecx,dword ptr [cp]		//把cp的内容放置在ecx寄存器
mov		dword ptr [cp2],ecx		//把寄存器ecx内容放置在cp2中

char* cp3 = cp++;
//汇编代码：
mov		eax,dword ptr[cp]		//把cp指针内容放置在eax寄存器中
mov		dword ptr[cp3],eax		//把eax内容直接放在cp3指针
mov		ecx,dword ptr[cp]		//把cp信息放置在exc寄存器中
add		ecx,1					//ecx+1操作
mov		dword ptr[cp],ecx		//ecx内容写入cp指针

int a = 1,b=2；
int c;
int d;
c = a+++b;   //相当于a++ +b。连续读取，当读取到两个+号时不能再组成新符号了
d = a++++b;	//相当于a++ ++b。这个是错误的 ，不构成任何运算

#include <iostream>
using namespace std;

int  a = 0;                       //GVAR全局初始化区
int* p1;						  //BSS全局未初始化区

int main()						 //text 代码区
{
	int b = 1;                    //stack栈区
	char s[] = "abc";			  //stack栈区
	int* p2 = NULL;				  //stack栈区

	const char* p3 = "123456";    //"123456\0"在常量区，p3在stack栈区

	static int c = 0;             //GVAR全局(静态)初始化区

	p1 = new int(10);            //heap堆区变量
	p2 = new int(20);            //heap堆区变量

	char* p4 = new char[7];      //heap堆区变量
	strcpy_s(p4, 7, "123456");   //text代码区

	if (p1 != NULL)
	{
		delete p1;
		p1 = NULL;
	}

	if (p2 != NULL)
	{
		delete p2;
		p2 = NULL;
	}

	//p3指向常量区，由内存接管

	if (p4 != NULL)
	{
		delete[] p4;
		p4 = NULL;
	}

	return 0;
}

#include <string>
#include <iostream>
#include <memory> //智能指针头文件
using namespace std;
int main()
{
	{// 确定auto_ptr失效的范围
		// 对int使用
		auto_ptr<int> pI(new int(10));      //关注pI的生命周期范围和指向的堆区空间的声明周期范围
		cout << *pI << endl;                // 10 

		// auto_ptr	C++ 17中移除	拥有严格对象所有权语义的智能指针
		// auto_ptr原理：在拷贝 / 赋值过程中，直接剥夺原对象对内存的控制权，转交给新对象，
		// 然后再将原对象指针置为nullptr（早期：NULL）。这种做法也叫管理权转移。
		// 他的缺点不言而喻，当我们再次去访问原对象时，程序就会报错，所以auto_ptr可以说实现的不好，
		// 很多企业在其库内也是要求不准使用auto_ptr。

		//对字符串数组使用
		auto_ptr<string> languages[5] = {
			auto_ptr<string>(new string("C")),
			auto_ptr<string>(new string("Java")),
			auto_ptr<string>(new string("C++")),
			auto_ptr<string>(new string("Python")),
			auto_ptr<string>(new string("Rust"))
		};
		cout << "There are some computer languages here first time: \n";
		for (int i = 0; i < 5; ++i)
		{
			cout << *languages[i] << endl;
		}
		auto_ptr<string> pC;
		pC = languages[2]; // languges[2] loses ownership. 将所有权从languges[2]转让给pC!!!
		//此时languges[2]不再引用该字符串从而变成空指针
		cout << "There are some computer languages here second time: \n";
		for (int i = 0; i < 2; ++i)
		{
			cout << *languages[i] << endl;
		}
		cout << "The winner is " << *pC << endl;
		//下面会报错
		//cout << "There are some computer languages here third time: \n";
		//for (int i = 0; i < 5; ++i)
		//{
		//	cout << *languages[i] << endl;
		//}
	}
	return 0;
}

//memory文件

//观察auto_ptr的模板可以看到它是怎么实现资源释放和所有权转移的

//资源释放：是通过析构来完成的
~auto_ptr() noexcept {
        delete _Myptr;
    }


//所有权转移，观察赋值的重载：
auto_ptr& operator=(auto_ptr& _Right) noexcept {
        reset(_Right.release());   //保存原有的地址，把原有保存这个地址的指针置成Nullptr
        return *this;
    }

#include <memory>
#include <iostream>
using namespace std;
int main()
{
	// 在这个范围之外，unique_ptr被释放
	{
		auto i = unique_ptr<int>(new int(10));
		cout << *i << endl;
	}

	// unique_ptr
	auto w = std::make_unique<int>(10);
	cout << *(w.get()) << endl;                          // 10。get()方法返回的就是指针

	//auto w2 = w;  // 编译错误！！如果想要把 w 复制给 w2, 是不可以的。
	//  因为复制从语义上来说，两个对象将共享同一块内存。

	// unique_ptr 只支持移动语义, 即如下
	auto w2 = std::move(w); // w2 获得内存所有权，w 此时等于 nullptr
	cout << ((w.get() != nullptr) ? (*w.get()) : -1) << endl;       // -1
	cout << ((w2.get() != nullptr) ? (*w2.get()) : -1) << endl;   // 10
	return 0;
}

#include <iostream>
#include <memory>
using namespace std;
int main()
{
	// shared_ptr 
	{
		//shared_ptr 代表的是共享所有权，即多个 shared_ptr 可以共享同一块内存。
		auto wA = shared_ptr<int>(new int(20));
		{
			auto wA2 = wA;          //shared_ptr可以赋值，同时指向对象
			cout << ((wA2.get() != nullptr) ? (*wA2.get()) : -1) << endl;       // 20
			cout << ((wA.get() != nullptr) ? (*wA.get()) : -1) << endl;         // 20
			cout << wA2.use_count() << endl;              // 打印引用计数 2
			cout << wA.use_count() << endl;               // 打印引用计数 2
		}
		//cout << wA2.use_count() << endl;                                               
		cout << wA.use_count() << endl;                  // wA2消亡，引用计数为1
		cout << ((wA.get() != nullptr) ? (*wA.get()) : -1) << endl;        // 20
		//shared_ptr 内部是利用引用计数来实现内存的自动管理，每当复制一个 shared_ptr，
		//	引用计数会 + 1。当一个 shared_ptr 离开作用域时，引用计数会 - 1。
		//	当引用计数为 0 的时候，则 delete 内存。
	}
	//跳出作用域，wA也消亡，同时内存会被释放

	// shared_ptr也支持move()语法
	auto wAA = std::make_shared<int>(30);
	auto wAA2 = std::move(wAA); // 此时 wAA 等于 nullptr，wAA2.use_count() 等于 1
	cout << ((wAA.get() != nullptr) ? (*wAA.get()) : -1) << endl;          // -1
	cout << ((wAA2.get() != nullptr) ? (*wAA2.get()) : -1) << endl;      // 30
	cout << wAA.use_count() << endl;              // 0
	cout << wAA2.use_count() << endl;             // 1
	//将 wAA 对象 move 给 wAA2，意味着 wAA 放弃了对内存的所有权和管理，此时 wAA对象等于 nullptr。
	//而 wAA2 获得了对象所有权，但因为此时 wAA 已不再持有对象，因此 wAA2 的引用计数为 1。

	return 0;
}

#include <string>
#include <iostream>
#include <memory>
using namespace std;

struct B;
struct A {
	shared_ptr<B> pb;
	~A()
	{
		cout << "~A()" << endl;
	}
};
struct B {
	shared_ptr<A> pa;
	~B()
	{
		cout << "~B()" << endl;
	}
};

// pa 和 pb 存在着循环引用，根据 shared_ptr 引用计数的原理，pa 和 pb 都无法被正常的释放。
// weak_ptr 是为了解决 shared_ptr 双向引用的问题。
struct BW;
struct AW
{
	shared_ptr<BW> pb;
	~AW()
	{
		cout << "~AW()" << endl;
	}
};
struct BW
{
	weak_ptr<AW> pa;
	~BW()
	{
		cout << "~BW()" << endl;
	}
};

void Test()
{
	cout << "Test shared_ptr and shared_ptr:  " << endl;
	shared_ptr<A> tA(new A());                                               
	shared_ptr<B> tB(new B());                                                
	cout << tA.use_count() << endl;  //1
	cout << tB.use_count() << endl;  //1
	tA->pb = tB;
	tB->pa = tA;
	cout << tA.use_count() << endl;     // 2
	cout << tB.use_count() << endl;     // 2
}
void Test2()
{
	cout << "Test weak_ptr and shared_ptr:  " << endl;
	shared_ptr<AW> tA(new AW());
	shared_ptr<BW> tB(new BW());
	cout << tA.use_count() << endl;    // 1
	cout << tB.use_count() << endl;    // 1
	tA->pb = tB;
	tB->pa = tA;   //weak_ptr不会对tA的引用计数产生影响
	cout << tA.use_count() << endl;    // 1
	cout << tB.use_count() << endl;    // 2
}

int main()
{
	Test();
	Test2();


	return 0;
}

int x1 = 1,x2 = 3;
int& rx = x1;	//定义引用，可以认为rx是x1的别名
rx = 2;
cout<<x1<<rx<<endl;	//x1和rx都是2
rx = x2;		//引用一旦被初始化就不能更改，所以这里不是赋值rx为x2，而是x1=x2(别名直接替换)
cout<<x1<<x2<<endl;		//都是3

#include <iostream>
#include <assert.h>
using namespace std;

// 编写一个函数，输入两个int型变量a,b
// 实现在函数内部将a,b的值进行交换。
void swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
void swap2(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int main()
{
	// 交换变量的测试
	int a = 3, b = 4;
	swap(a, b);
	assert(a == 4 && b == 3);

	a = 3, b = 4;
	swap2(&a, &b);
	assert(a == 4 && b == 3);

    return 0;
}

const char* pStrHelloWorld = "helloworld";

int main()
{
	char strHello[11] = { "helloworld" };
	//strHello是数组变量，它本身的值是不允许改变的，但是它指向的区域的值strHello[index]是可以改变的
	strHello[2] = '6';    //strHello = he6loworld
	//strHello = { "helloworld" };    //不允许改变了，编译不通过


	//ptrHello是指针变量，它本身是可以改变的，但是ptrHello[index]指向的值可变与否要取绝与所指向的区间是否可以改变
	const char* ptrHello_1 = "helloworld";  //指针指向常量区(必须要加const)，ptrHello[index]不可改变，但本身指向的地址可以变。
	ptrHello_1 = "change";

	char tmp[7] = "change";
	char* ptrHello_2 = strHello;      //指针指向数组变量，ptrHello[index]可以改变,本身也可以变
	ptrHello_2[2] = 'l';
	ptrHello_2 = tmp;

	return 0;
}

strlen(s);    //返回字符串s的长度，要注意字符串的长度不包含'\0'。

sizeof(s);   //返回字符串所占用的空间，包含'\0'


int main()
{
	char strA[11] = "helloworld";
	auto n1 = sizeof(strA);     //11
	auto n2 = strlen(strA);     //10


	wchar_t strB[11] = L"helloworld";
	auto n3 = sizeof(strB);        //22
	auto n4 = wcslen(strB);        //10

	return 0;
}

strcmp(s1,s2); 
wcscmp(s1,s2); 
//s1 == s2,返回0
//s1 < s2 ,返回值小于0
//s1 > s2 ，返回值大于0

strcpy(s1,s2);   //赋值字符串s2到字符串s1

strncpy(s1,s2,n);   //将字符串s2中的前n个字符拷贝到s1中

strcat(s1,s2);   //将字符串s2拼接到s1后面

strchr(s1,ch);   //指向字符串s1中字符ch第一次出现的位置
strstr(s1,s2);   //指向字符串s1中字符串s2的第一次出现的位置

#include<string>
using namespace std;

string s;   //定义空字符串
string s = "helloworld";  //定义并初始化
string s("helloworld");
string s = string("helloworld");

cout<<s1.length()<<endl;    //输出字符串长度
cout<<s1.size()<<endl;      //本质和上面一样
cout<<s1.capacity()<<endl;  // 字符串的容量

string s1 = "hello";
const char* c_str1 = s1.c_str();

string s = "hello";
cout<<s[0]<<endl;

string s1 = "hello";
string s2 = s1;

string s1 = "hell0",s2 = "world";
string s3 = s1+s2;
s1 += s2;

//推荐的方式：
for(int index=0;index < 10;++index)
{
	cout<<a[index]<<" ";
}

//不推荐的方式
for(int index=0;index <= 9;++index)
{
	cout<<a[index]<<" ";
}

//下标访问
a[2] = 5;

//指针访问
int* p = a;
*(p+2) = 5;

//寻找a[]中第一个值为3的目标：
int len = sizeof(a)/sizeof(a[0]);
for(int index = 0;index<len;++index)
{
	if(a[index] == 3)
	{
		return index;
	}
}

int a[2][4] = {{1,2,3,4},{5,6,7,8}};
for(int row=0;row<2;++row)
{
	for(int col = 0;col<4;++col)
	{
		cout<<a[row][col]<<" ";
	}
	cout<<endl;
}

#include<vector>
using namespace std;

int main()
{
	vector<int> vec = { 1,2,3,4 };

	//尾添加
	vec.push_back(5);  //尾添加，不会出现下标越界 {1,2,3,4,5}


	//指定位置添加
	//insert方法，传入位置和值
	vec.insert(--vec.end(), 4);   //{1,2,3,4,4,5}
	return 0;
}

for(int index = 0;index < vec.size();++index)
{
	cout<<vec[index]<<endl;
}

vec.pop_back();
vec.eraser(vec.end()-1);   //这两者等价

#include<iostream>
using namespace std;
int main()
{
	bool A = false;
	bool B= true;
	//德摩根率：
	cout<<(!(A || B) == (!A && !B))<<endl;  //输出1
	cout<<(!(A && B) == (!A || !B))<<endl;  //输出1
}

#include<iostream>
#include<assert.h>
using namespace std;
int main()
{
	bool A = false;
	bool B= true;
	//德摩根率：
	assert( !(A || B) == (!A && !B) );  
	assert( !(A && B) == (!A || !B) );  
}

assert(函数返回值 == 预期结果);