C/C++学习笔记（2020.11---2021.5）

c++98: #define __cplusplus  199711L

c++03: #define __cplusplus  199711L

c++11: #define __cplusplus  201103L

c++14: #define __cplusplus  201402L

c++17: #define __cplusplus  201500L

main.c -> gcc -E -> main.i

main.i -> gcc -S -> main.s

main.s -> gcc -c -> main.o

./a.out

// 此处编写规范lib+
ar rcs libcalc.a 原始二进制文件

gcc main.c -o main -L include/ -lcalc

g++ -fPIC -c libadd.cpp -I head/		// 生成.o
g++ -shared -o libadd.so libadd.o		// 生成.so

// 编写规范lib+
gcc main.c -o main -L include/ -lcalc

// 输出字符串
➜  C echo Hello World
Hello World
// 输出变量
➜  C echo $HOME
/home/liuhao

➜  C ldd test
	linux-vdso.so.1 (0x00007fff19dfe000)
	libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f0d142a2000)		// C语言链接库
	/lib64/ld-linux-x86-64.so.2 (0x00007f0d144a3000)		// 链接器

// 第一个位置,这是./usr/lib的软链接
cd ./lib
// 第二个位置
cd ./usr/lib

// 放置的都是绝对路径
sudo ln -s ~/code/C/lib/libc.so /lib/lib.so

// LD_LIBRARY_PATH查看变量
echo $LD_LIBRARY_PATH
// 给动态链接库设置库环境变量
export LD_LIBRARY_PATH=/home/code/C/lib:$LD_LIBRARY_PATH

➜  /etc sudo vim ld.so.conf
include /etc/ld.so.conf.d/*.conf

/home/liuhao/code/C/lib

ldconfig -v

gcc -std=c99 inform.c
gcc -std=c1x inform.c
gcc -std=c11 inform.c

// 使用cpp标准库
gcc demo.cpp -libstdc++

高版本的gcc向下兼容，支持低版本的C++标准。

Visual Studio 6 ： vc6 
Visual Studio 2003 ： vc7 
Visual Studio 2005 ： vc8 
Visual Studio 2008 ： vc9 
Visual Studio 2010 ： vc10 
Visual Studio 2012 ： vc11 
Visual Studio 2013 ： vc12 
Visual Studio 2015 ： vc14 
Visual Studio 2017 ： vc15

namespace namespace_name {
   // 代码声明
}

name::code;  // code 可以是变量或函数

#include <iostream>
using namespace std;
 
// 第一个命名空间
namespace first_space{
   void func(){
      cout << "Inside first_space" << endl;
   }
}
// 第二个命名空间
namespace second_space{
   void func(){
      cout << "Inside second_space" << endl;
   }
}
int main ()
{
 
   // 调用第一个命名空间中的函数
   first_space::func();
   
   // 调用第二个命名空间中的函数
   second_space::func(); 
 
   return 0;
}

#include <iostream>
using namespace std;
 
// 第一个命名空间
namespace first_space{
   void func(){
      cout << "Inside first_space" << endl;
   }
}
// 第二个命名空间
namespace second_space{
   void func(){
      cout << "Inside second_space" << endl;
   }
}
using namespace first_space;
int main ()
{
 
   // 调用第一个命名空间中的函数
   func();
   
   return 0;
}

// 给变量起别名，相当于typedef
using buyuan = void*;

class A {
	A();
	~A();
};
class B: public A {
	using A:A;
};

class A {
public:
	void size();
};
class B: private A {
	using A:size;
};

namespace namespace_name {
   // 代码声明
}

namespace namespace_name1 {
   // 代码声明
   namespace namespace_name2 {
      // 代码声明
   }
}

#define NAME 1

#define A(X, Y) ((X) < (Y))?X:Y

#define NAME(N) x ## n

NAME(1) = 14;		// x1 = 14
NAME(2) = 13;		// x2 = 13

void va_start(va_list ap, last_arg);

type va_arg(va_list ap, type)

void va_end(va_list ap)

#include <stdarg.h>
#include <stdio.h>

int mul(int, ...);

int main()
{
   printf("15 * 12 = %d\n",  mul(2, 15, 12) );
   
   return 0;
}

int mul(int num_args, ...)
{
   int val = 1;
   va_list ap;		// 定义一个指针
   int i;

   va_start(ap, num_args);		// 让指针绑定变参
   for(i = 0; i < num_args; i++) 
   {
      val *= va_arg(ap, int);		// 获取参数并运算
   }
   va_end(ap);		// 解除参数绑定
 
   return val;
}

#define A 10		// 定义宏A
#undef A		// 取消宏A的定义

#ifdef A
#include "B.h"	// 如果已经定义了宏A，执行
#else
#include "A.h"	// // 如果没有定义宏A，执行
#endif

#ifndef __STDIO_H__
#define __STDIO_H__
// do something
#endif

#if  A == 1
// do something
#elif A == 2
// ...
#else 
// ...
#endif

#if __STDC_VERSION__ != 201112L
#error NOT C11

#line 1000	// 把当前行号重置到1000行
#line 10 "cool.h"	// 把行号重置为10行，把文件名重置为cool.c

#pragma c9x on		// 使用C9X版本

sizeof(int);

int n = 1;		
// 其实就是把负数部分的数值范围加到正数部分
unsigned int n = 1;

float a = 2.3;		// 单精度
double b = 4.5;		// 双精度,当创建一个临时浮点数数值的时候，默认是double

#include <iostream>
int main() {

    char str[] = "asb";
    // 末尾自动添加一个'\0',占4个字节
    std::cout << sizeof(str) << std::endl; 
         
    char str2[] = "刘浩asb";
    // 占用10个字节，一个中文2个字节，末尾无'\0'，不合法
    std::cout << sizeof(str2) << std::endl;   
      
    wchar_t str3[] = L"刘浩asb";
    // 占用12个字节，一个字符两个字节，末尾添加一个'\0'
    std::cout << sizeof(str3) << std::endl;   
      
	return 0;
}

// vcruntime.h line 192~195
#ifdef _WIN64
    typedef unsigned __int64 size_t;
    typedef __int64          ptrdiff_t;
    typedef __int64          intptr_t;

// inttypes.h line 109~117
//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
//
// Output Format Specifier Macros
//
//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#define PRId8        "hhd"		// short short int
#define PRId16       "hd"		// short int
#define PRId32       "d"		// int
#define PRId64       "lld"		// long long int

#include <stdio.h>
#include <inttypes.h>
int main() {
    int8_t m = 2;		// 8bit，即1bytes
    printf("memory: %d\n", sizeof(m));	// 1
    return 0;
}

int a = 1;
int b = ++a;		// b = 2

int a = 1;
int b = a++;		// b = 1

#include <stdio.h>

int main() {
    int a;
    int b;
    a = 1;
    b = 2;
    printf("%d\n", a & b);		// 0
    printf("%d\n", a | b);		// 3
    return 0;
}

/*
规则 1：char、short 和 unsigned short 值自动升级为 int 值。细心的读者可能已经注意到，char、short 和 unsigned short 都未出现在表 1 中，这是因为无论何时在数学表达式中使用这些数据类型的值，它们都将自动升级为 int 类型。

规则 2：当运算符使用不同数据类型的两个值时，较低排名的值将被升级为较高排名值的类型。

规则 3：当表达式的最终值分配给变量时，它将被转换为该变量的数据类型。

规则 4：当变量值的数据类型更改时，它不会影响变量本身
*/

// (type_name) expression
// type_name (expression)
#include <stdio.h>

main() {
   int sum = 17, count = 5;
   double mean;

   mean = (double) sum / count;
   printf("Value of mean : %f\n", mean );
}
// output：Value of mean : 3.400000

const int g = 20;
//int h = const_cast<int>(g); //不允许对普通数据进行操作
int *h = const_cast<int*>(&g);//去掉const常量const属性

const int g0 = 20;
const int &g2 = g0;
int &h = const_cast<int &>(g0);//去掉const引用const属性
int &h2 = const_cast<int &>(g2);//去掉const引用const属性

const char *g1 = "hello";
char *h = const_cast<char *>(g1);//去掉const指针const属性

char str[] = {"Hello Wprld"};

char p = 'x';
sizeof(p);		// 1

char o[] = "x";
sizeof(o);		// 2,末尾有一个\0

char str[] = "abc";
strlen(str);		// 3,不计算\0

char str1[] = "H";
char str2[] = "h";
strcmp(str1, str2);		// 1

char str1[] = "H";
char str2[] = "h";
strcat(str1, str2);		// str1:Hh

#define NAME 1

const int MON = 12;

// limits.h line 32~34
#define SHRT_MIN    (-32768)		// short最小值
#define SHRT_MAX      32767		// short最大值
#define USHRT_MAX     0xffff		// unsigned short最大值

// float.h line 71~75
#define DBL_DECIMAL_DIG  17                      // # of decimal digits of rounding precision
#define DBL_DIG          15                      // # of decimal digits of precision
#define DBL_EPSILON      2.2204460492503131e-016 // smallest such that 1.0+DBL_EPSILON != 1.0
#define DBL_HAS_SUBNORM  1                       // type does support subnormal numbers
#define DBL_MANT_DIG     53                      // # of bits in mantissa

#define BUFSIZ  512

_Check_return_opt_
    _CRT_STDIO_INLINE int __CRTDECL printf(
        _In_z_ _Printf_format_string_ char const* const _Format,
        ...)
    #if defined _NO_CRT_STDIO_INLINE
    ;
    #else
    {
        int _Result;
        va_list _ArgList;
        __crt_va_start(_ArgList, _Format);
        _Result = _vfprintf_l(stdout, _Format, NULL, _ArgList);
        __crt_va_end(_ArgList);
        return _Result;
    }
    #endif

#include <stdio.h>
int main() {
	int n = printf("Hello Wprld");
	return 0;
}
// output: 11

int sprintf(char *str, const char *format, ...)

#include <stdio.h>

int main() {
    char information[100];
    char *name = "Li, Lei";
    char *gender = "male";
    int age = 14;
    float height = 187.5f;
    // 请在这里使用 sprintf
    sprintf(information, "%s is a %s. He is %d-year-old and %fcm tall.", name, gender, age, height);
    printf("%s", information);
}

#define EOF    (-1)

int a;
scanf("%d", &a);

#include <stdio>
int main() {
	char ch;
	while (ch = getchar() != '#') {
		putchar(ch);
	}
	return 0;
}

// stdio.h 
// C中定义缓冲区的大小为512个字节
#define BUFSIZ  512

char *gets(char *str)

int puts(const char *str)

operator cout << data

#include <iostream>
using namespace std;
int main() {
    char arr[] = "Hello World";
    cout.put(arr[0]);       // cout << arr[0]
    cout.write(arr, 2);     // cout << arr[0] << arr[1]
    return 0;
}

cout << "PL;";
float num;
cin >> num;

cout << "PL;" << flush;
cout << "Hello World" << endl;

#include <iostream>
using namespace std;
int main() {
    int n = 10;
    cout << hex;        // 十六进制显示
    cout << n << endl;
    cout << dec;        // 十进制显示
    cout << n << endl;
    cout << oct;        // 八进制显示
    cout << n << endl;
    return 0;
}

#include <iostream>
using namespace std;
int main() {
    int n = 10;
    cout.width(10);		// 字符宽度为10
    cout << hex;        // 十六进制显示
    cout << n << endl;
    cout.width(10);
    cout << dec;        // 十进制显示
    cout << n << endl;
    cout.width(10);
    cout << oct;        // 八进制显示
    cout << n << endl;
    return 0;
}

#include <iostream>
using namespace std;
int main() {
    int n = 10;
    cout.fill('*');
    cout.width(10);
    cout << hex;        // 十六进制显示
    cout << n << endl;
    cout.width(10);
    cout << dec;        // 十进制显示
    cout << n << endl;
    cout.width(10);
    cout << oct;        // 八进制显示
    cout << n << endl;
    return 0;
}
/*
*********a
********10
********12
*/

#include <stdio.h>
#include <iostream>
using namespace std;
int main() {
    float m = 3.45;
    cout.precision(2);
    cout << m << endl;      // 3.5
    cout.precision(1);
    cout << m << endl;      // 3
    return 0;
}

#include <stdio.h>
#include <iostream>
using namespace std;
int main() {
    float m = 3.45;
    cout.precision(2);
    cout << m << endl;      // 3.5

    cout.precision(4);
    cout.setf(ios_base::showpoint);
    cout << m << endl;      // 3.450
    return 0;
}

fmtflags setf(fmtflags);

fmtflags setf(fmtflags, fmtflags);

#include <iostream>
using namespace std;
int main() {
    int m;
    cin >> m;
    cout << m << endl;
    char s;
    cin >> s;
    cout << s << endl;
    return 0;
}
// 123Z
// 123
// Z

#include <iostream>
#include <ios>
using namespace std;
int main() {
    int m;
    cin >> m;
    if (cin.fail()) {
        cin.clear(ios_base::goodbit);
        cin.sync();     // 清空流
    }
    return 0;
}

cin.get(ch);

ch = cin.get();

char line[50];
cin.get(line);
cin.get(line, 50);

cin.getline(line);
cin.getline(line, 50);

/*	
if语句的三种格式：
	单行格式if语句：if(条件){条件满足执行的语句};
	多行格式if语句：if(条件){条件满足执行的语句}else{条件不满足执行的语句};
	多条件的if语句：if(条件1){条件1满足执行的语句}else if(条件2){条件2满足执行的语句}...else{都不满足执行的语句}
*/

switch("表达式")
{
    case "结果1":执行语句;break;
    case "结果2":执行语句;break;
    case "结果3":执行语句;break;
    ...
    default:执行语句;break;
}

int num = 1;
while(num < 5){
    cout << "输出的数字为：" << endl;
    num++;
}

int main() {
    int num = 0;
    do{
        cout << num << endl;
        num++;
    }
    while(num < 10){
        system("pause")
    }
}

int main() {
    for (int i = 0; i < 10; i++){
        cout << i << endl;
    }
    system("pause");
    return 0;
}

int main() {
    for (int i = 1; i < 10; i++){
        if (i % 2 == 0){
            continue;
        }
        cout << i << endl;
    }
    system("pause");
    return 0;
}

int main() {
    cout << "1" << endl;
    goto FLAG;
    cout << "2" << endl;
    cout << "3" << endl;
    cout << "4" << endl;
    
    FLAG;
    cout << "5" << endl;
    system("pause");
    return 0;
}

int arr[] = {1, 2, 4, 5};

// 空缺的部分用\0代替
int arr[20] = {3, 2, 4, 6};

/*
	1. 可以统计整个数组在内存中的长度:sizeof(arr)
			获取数组长度：(1). 数据类型是字符串：strlen();
						(2). 其他：sizeof(arr)/sizeof(arr[0])
			末尾元素的下标：sizeof(arr)/sizeof(arr[0]) - 1
	2. 可以获取数组在内存中的首地址(原本输出的是十六进制,int转化成十进制来查看):(int*)arr或者arr转为																				printf("%d", arr);
    																或printf("%I64d", arr);
	3. 可以看数组中第一个元素的地址：(int*)&arr[0]或者&arr[0]转为同上
	*/

#include <iostream>
#include <inttypes.h>
#include <stdint.h>
#include <limits.h>
#include <float.h>
#include <stdio.h>
using namespace std;
int main() {
    int arr[] = {2, 3, 5};
    // 数组名即首元素地址
    cout << arr << endl;
    // 解引用，2
    cout << *arr << endl;
    // 获得第二个元素的地址
    cout << &(*(arr+1)) << endl;
    // 获得第二个元素的值
    cout << *(arr+1) << endl;
    return 0;
}

int arr[10][11] = { 0 };
int arr[][] = {
	{1, 2, 3},
	{3, 4, 5}
};

int arr[2][2] = {
	{1, 2},
	{4, 3}
}

/*
	1. 查看二维数组所占内存空间：sizeof(arr)
	2. 查看二维数组第一行所占内存空间：sizeof(arr[0])
	3. 查看二维数组第一个元素所占内存空间：sizeof(arr[0][0])
	4. 获取二维数组的首地址：int(arr)
	5. 可以看数组中第一行元素的地址：(int)&arr[0]
	6. 可查看数组中第一个元素的地址：(int)&arr[0][0]
*/

int *p[3];		// 表示一个含有三个int型指针的数组
int (*p)[3];		// 表示一个含有三个元素的指针

char str[] = "Hello World";
sizeof(str);		// 12,末尾有一个\0

返回值类型 函数名 (参数列表){
    函数名语句
        return 表达式
}

// 函数定义
int add(int num1, int num2){		// 定义中的num1,num2成为参数形式，简称形参
    int sum = num1 + num2;
    return sum;
}
int main() {
    int a = 10;
    int b = 10;
    // 调用add函数
    int sum = add(a, b);		// 调用时的a,b成为实际参数，简称实参
    cout << sum << endl;
    system("pause");
    return 0;
}

#include<iostream>
using namespace std;
// 函数的声明
int max(int a, int b);

int max(int a, int b){
    return a > b ? a : b 
}
int main() {
    int a = 1;
    int b = 2;
    cout << max(a, b) << endl;
    system("pause");
    return 0;
}

double func(int m, int n) {}
void print((double)(*func)(int m, int n)) {}

void func(int a, int b) {}
void func(int c) {}

inline void print() {}

// 值捕获
void func()
{
	int i = 100;//局部变量
	//将i拷贝到明位f的可调用对象
	auto f = [i] { return i; };
	i = 0;
	int j = f(); //j=100,因为i是创建时拷贝的
}
// 引用捕获
void func()
{
	int i = 100;//局部变量
	//对象f包含i的引用
	auto f = [&i] { return i; };
	i = 0;
	int j = f(); //j=0,传递的是引用
}

//代码在VS2019中测试
void func()
{
	int i = 1, j = 2;
	auto f = [](int a,int &b) {
		a = 10;
		b = 20;
		//输出：10  20
		std::cout << a << " " << b << std::endl;
	};
	f(i,j);
	//输出：1 20
	std::cout << i << " " << j << std::endl;
}

void func()
{
	auto f = []() ->double {
		if (1 > 2)
			return 1;
		else 
			return 2.0;
	};
	std::cout << f() << std::endl;
}

//代码在VS2019中测试
void func()
{
	int i = 10, j = 10;
	//加上mutable才可以在lambda函数中改变捕获的变量值
	auto f = [i, &j]() mutable {
		i = 100, j = 100;
	};
	i = 0, j = 0;
	f();
	//输出:0 100
	std::cout << i << " " << j << std::endl;
}

// 结构体定义
struct Student{
    // 成员列表
    string name;	// 姓名
    int age;	// 年龄
    int score;	//分数 
}
int main() {
    // struct 结构体名 变量名；
    struct Student s1;
    // 给s1属性赋值，通过访问结构体变量中的属性
    s1.name = "张三";
    s1.age = 13;
    s1.score = 99;
    
    //struct 结构体名 变量名 = {成员1值，成员2值}
    struct Student s2 = {"张三", 23, 98};
    
    /* 
    定义结构体时顺便创建变量
    	struct Student{
    	// 成员列表
    	string name;	// 姓名
    	int age;	// 年龄
    	int score;	//分数 
	}s3;
    */
    s3.name = "张三";
    s3.age = 13;
    s3.score = 99;
    system("pause");
    return 0;
}

typedef struct LNode {
	...
}LNode;

// 结构体定义
struct Student{
    // 成员列表
    string name;	// 姓名
    int age;	// 年龄
    int score;	//分数 
}
int main() {
    // 结构体数组
    struct Student arr[3] = {
        {"张三", 13, 34},
        {"李四", 23, 45},
        {"王五", 12, 45}
    }
    // 给结构体数组的元素赋值
    arr[2].name = "赵六";
    arr[2].age = 34;
    arr[2].score = 78;
    // 遍历结构体数组
    for(i = 0;i <3; i++){
        cout << arr[i].name;
        cout << arr[i].age;
        cout << arr[i].score;
        cout << endl;
    }
}

// 结构体定义
struct Student{
    // 成员列表
    string name;	// 姓名
    int age;	// 年龄
    int score;	//分数 
}
int main() {
    // 创建学生结构体变量
    struct Student stu = {"张三", 12, 34};
    // Student stu = {"张三", 12, 34};    // 结构体作为一个数据类型，也可以写成数据类型 变量 = ...格式
    // 通过指针指向结构体变量
    struct Student * p = &stu;
    // Student * p = &stu;
    // 通过指针访问结构体变量中的数据
    cout << p -> age;
    cout << p -> name;
    cout << p -> socre;
    cout << endl;
}

#include<iostream>
using namspace std;
#include<string>
// 结构体定义
struct Student {
    // 成员列表
    string name;	// 姓名
    int age;	// 年龄
    int score;	//分数 
}
struct Teacher {
    // 成员列表
    int id;	// 编号
    string name ;	// 姓名
    int age;	//分数     
    struct Student stu;	// 辅导的学生
}
int main() {
    // 结构体嵌套结构体
    struct Teacher t;
    t.id = 1000;
    t.name = "不圆";
    t.age = 99;
    t.stu.name = "八戒";
    t.stu.age = 45;
    t.stu.score = 56;
    cout << t.id;
    cout << t.name;
    cout << t.age;
    cout << t.stu.name;
    cout << t.stu.age;
    cout << t.stu.score;
}

#include<iostream>
using namspace std;
#include<string>
// 结构体定义
struct Student {
    // 成员列表
    string name;	// 姓名
    int age;	// 年龄
    int score;	//分数 
}
// 值传递,形参发生了改变不会影响实参
void printStudent(struct Student stu){		// 或者(Student stu)
    cout << stu.name;
    cout << stu.age;
    cout << stu.score;
    cout << endl;
}
int main() {
    struct Student stu;
    stu.name = "张三";
    stu.age = 21;
    stu.score = 89;
    printStudent(stu) 
}

// 地址传递，形参发生了改变会影响实参
void printStudent(struct Student *p){
    cout << p->name << endl;
}
int main() {
    struct Student stu;
    stu.name = "张三";
    stu.age = 21;
    stu.score = 89;
    printStudent(&stu) 
}

#include<iostream>
using namspace std;
#include<string>
// 结构体定义
struct student {
    // 成员列表
    string name;	// 姓名
    int age;	// 年龄
    int score;	//分数 
}
// 将形参改成指针，可以减少内存空间，而且不会复制出新的副本出来
void printstudent(const struct student *s) {
    // s -> = 150		加入const后不可修改
    cout << s->name;
    cout << s->age;
    cout << s->score;
    cout << endl;
}
int main() {
    // 创建结构体变量
    struct student s = {"张三", 23, 34};
    printstudent(&s);
    system("pause");
    return 0;
}

enum　枚举名　{枚举元素1,枚举元素2,……};

enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};

union [union tag]
{
   member definition;
   member definition;
   ...
   member definition;
} [one or more union variables];

struct A {		// 16
	int a;		// 4
	short b;		// 2
	int c;		// 4
	char d;		// 1
};

union st {		// 4 + 8 + 1 = 13，对齐8，则为16
	int n;		// 4
	double g;		// 8
	char a[9];		// 1
};

#include <iostream>
using namespace std;

int main() {
    int a = 1;
    int* p = &a;
    cout << p << endl;		// 0x61fe14
}

int main() {
    // 1. 定义指针
    int a = 1;
    // 2. 指针定义的语法：数据类型 * 指针变量名
    int * p;
    // 3. 让指针记录变量a的地址
    p = &a;
    cout << "a的地址为" << &a << endl;
    cout << "a的地址为" << p << endl;
    // 4. 使用指针
    // 可以通过解引用的方式来找到指针指向的内存
    // 指针前加一个*代表解引用找到数据并修改内存
    *p = 1000;
    cout << a <<endl;
    cout << p <<endl;
    system("pause");
    return 0;
}

#include<iostream>
using namespace std;
// 判断一个数是否是回文数
int main() {
    char s[71], *p;
    get(s);		// 标准库函数get()与cin类似甚至更好
    top = &s[0];		// top值表示的是s变量的首地址
    end = &s[sizeof(s)-1];		// end表示的是s变量的最后一个字节的地址，此处还可用&s[strlen(s)-1]
    for(top, end;top < end; top++, end--) {		// 此处end是高地址,top是低地址
        if(*top != *end) { break; }
    }
    if(top >= end) { 
        cout << "是一个回文数" << endl;
    }else {
        cout << "不是回文数" << endl;
    }
	system("pause");
	return 0;
}
/*
	指针的相减和赋值运算
	如果指针p1指向数组a里面的第二个元素a[1],指针p2指向数组a里面的第五个元素a[4],那么p1 - p2 = 3（表示的是两指针所指变量之间相距的同类型变量的个数）
	指针没有相加运算，没有任何意义
*/

#include <iostream>
using namespace std;

int main() {
    int a = 1;
    int* p = &a;
    cout << sizeof(p) << endl;		// 8
}

int main() {
    // 指针变量指针内存中编号为0的空间
    int * p = NULL;
    // 访问空指针报错
    // 内存编号0~255位系统所占内存，不允许用户访问
    // *p = 100;
    cout << *p << endl;
    system("pause");
    return 0;
}

int main() {
    // 指针变量p指向内存地址中编号为0x1100的空间
    int * p = (int *)0x1100;
    // 访问野指针报错
    cout << *p << endl;
    system("pause");
    return 0;
}

int main() {
    int a = 10;
    int b = 10;
    // const修饰的是指针，指针指向可以改，指针指向的值不可以更改
    const int * p1 = &a;
    p1 = &b;	// 正确
    // *p1 = 100; 报错
    
    // const修饰的是常量，指针指向不可以改，指针指向的值可以更改
    int * const p2 = &a;
    // p2 = &b;	错误
    *p2 = 100;		// 正确
    
    // const修饰的是常量，指针指向不可以改，指针指向的值可以更改
    const int * const p3 = &a;
    *p3 = 100;		// 错误
    p4 = &b;		// 错误
}

// 对于一维数组
int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    // 指向数组的指针，此时arr代表的是数组的首地址,数组名可以认为是一个常量指针，因此可以直接写成int * p = arr;
    int * p = arr;		//这里的arr=&arr[0] 
    cout << "第一个元素：" << arr[0] << endl;
    cout << "指针访问的第一个元素：" << *p << endl;
    p++;		// 让指针向后偏移4个字节
    for(int i = 0; i < 10; i++){
        cout << *p << endl;
        P++;
    }
    system("pause");
    return 0;
}
// 对于二维数组
int main() {
    int a[3][3] = {{1, 3, 5}, {7, 9, 11}, {13, 15, 17}}
    int *p = a[0];		// p是一个执行整型变量的指针，他可以指向一般的整型变量，也可以指向数组中的元素
    for(p; a[0] < a[0] + 8; p++) {
        cout << *p << " ";
        cout << endl;
    }
}

char* str = "Hello";

char* str = 0xffff;

// 值传递
void max(int a, int b){
    int temp = a;
    a = b;
    b = temp;
}
// 地址传递
void max(int * p1, int * p2){		// 传入的必须是一个地址&a
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}
// 针形函数
void *func(int x) {		// 返回值必须是一个int型指针
    cout << x << endl;
}
int main() {
    int a = 1;
    int b = 2;
    max(&a, &b);
}

int* print() {}

void print((double)(*func)(int m, int n)){}

#include <memory>

auto_ptr<string> ps (new string("Hello World"));
auto_ptr<string> vocation;
vocation = ps;		// 将两个指针指向同一个string对象，这是不可接受的

auto_ptr<string> p1 (new string("Hello World"));
auto_ptr<string> p2;
p1 = p2;

unique_ptr<string> p1 (new string("Hello World"));
unique_ptr<string> p2;
p1 = p2;

unique_ptr<int[]> p (new int[3]{1,2,3});  
p[0] = 0;// 重载了operator[]

//

#include <vector>
std::vector<shared_ptr<string>> v;

int a = 10;
int &b = a;

// 2. 地址传递
void he(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
// 3. 引用传递
int my(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

// 返回局部变量引用，不可用
int& test01() {
    int a = 10;		// 局部变量在四区中的栈区
    return a;
}
// 返回静态变量引用
int& test02() {		// int& 函数名表示以引用的方式返回，其他如int* 函数名表示以指针的方式返回
    static int a = 10;
    return a;
}
int main() {
    int &ref = test01();
    cout << ref << endl;
    system("pause");
    return 0;
}

// 引用使用的场景，通常用来修饰形参
int main() {
    // 常量引用
    // 使用场景：用来修饰形参，防止误操作
    // int a = 10;
    // 加上const后编译器将代码修改
    const int &b = 10;		// 引用必须引一块合法分内存空间
    // ref = 10		报错，加上const后不可修改
    system("pause");
    return 0;
}

void getnum(const int &a) {		// int &a表示以引用的方式接收这个值，如果在外面则是以什么样的方式返回
    // a = 100;		// 不加const能直接修改
    cout << a << endl;
}
int main() {
    int a = 10;
    getnum(a);
}

int a = 0;		// 全局变量
int main() {
    int b = 1;		// 局部变量
    static int c = 2;		// 静态变量
}

void *func() {		// 返回为地址要加*
    // 利用new关键字将数据开辟到堆区
    int *p = new int(10);
    return p;
}
int main() {
    // 在堆区开辟数据
    int *p = func();
    cout << *p << endl;
    system("pause");
    return 0;
}

// 分配100个int类型的数字指针
// malloc
int* arr = (int*)malloc(sizoef(int), 100);
// calloc
int* arr = (int*)calloc(100, sizeof(int));
// free
free(arr);
arr = NULL;

// new的基本语法
int *func(){
    // 在堆区创建整型数据
    // new返回是 该数据类型的指针
    int *a = new int(10);
    return a;
}
void test01() {
    int *p = func();
    cout << *p << endl;
    // 堆区的数据，程序员手动开辟，手动释放
    // 释放利用操作符delete
    delete p;
}
// 在堆区利用new开辟数组
void test02() {
    // 创建10整型数据的数组，在堆区；
    int * arr = new int[10];		// 10代表数组有十个元素
    for(int i = 0;i < 10; i++) {
        arr[i] = i + 100
    }
    for(int i =0 ;i < 10; i++) {
        cout << arr[i] << endl;
    }
    // 释放数组的时候加上[]才可以
    delete[] arr;
}

string *ps = new string("Hello World");

void* operator new(size_t size);

// 和malloc一样，operator new的唯一任务就是分配内存
void* rawmemory = operator new(sizeof(string));

void* ps = new string("hello world");

// 取得原始内存，用来放置一个string对象
void* memory = operator new(sizeof(string));
// 将内存中的对象初始化，constructor动作
call string::string("hello world");
// 让ps指向新完成的对象
//static_cast强制类型转换，将void*空指针变成string*类型指针
string* ps = static_cast(memory);

class widget {
public:
widget(int widgetsize);
...
};
widget* constructwidgetinbuffer(void* buffer, int widgetsize) {
return new(buffer) widget(widgetsize);
}

string *ps;
...
delete ps; // delete operator

ps-> ~string(); // 调用对象的dtoroperator
operator delete(ps); // 释放对象所占用的内存

#include <iostream>
int main() {
	std::cout << "Hello World" << std::endl;
	return 0;
}

write(fd, "Hello World", 11);

sys_write("Hello World");

Hello World

FILE *fp;		// 创建一个文件描述符
fp = fopen("a.txt", "r");

FILE *fp;		// 创建一个文件描述符
fp = fopen("a.txt", "r");
char ch;
ch = getc(fp);
while (ch != EOF) {
	putchar(ch);
	ch = getc(fp);
}

int fprintf(FILE *stream, const char *format, ...)

#include <stdio.h>
#include <stdlib.h>

int main()
{
   FILE * fp;

   fp = fopen ("file.txt", "w+");
   fprintf(fp, "%s %s %s %d", "We", "are", "in", 2014);
   
   fclose(fp);
   
   return(0);
}

int fscanf(FILE *stream, const char *format, ...)

#include <stdio.h>
#include <stdlib.h>


int main()
{
   char str1[10], str2[10], str3[10];
   int year;
   FILE * fp;

   fp = fopen ("file.txt", "w+");
   fputs("We are in 2014", fp);
   
   rewind(fp);
   fscanf(fp, "%s %s %s %d", str1, str2, str3, &year);
   
   printf("Read String1 |%s|\n", str1 );
   printf("Read String2 |%s|\n", str2 );
   printf("Read String3 |%s|\n", str3 );
   printf("Read Integer |%d|\n", year );

   fclose(fp);
   
   return(0);
}

char *fgets(char *str, int n, FILE *stream)

#include <stdio.h>

int main()
{
   FILE *fp;
   char str[60];

   /* 打开用于读取的文件 */
   fp = fopen("file.txt" , "r");
   if(fp == NULL) {
      perror("打开文件时发生错误");
      return(-1);
   }
   if( fgets (str, 60, fp)!=NULL ) {
      /* 向标准输出 stdout 写入内容 */
      puts(str);
   }
   fclose(fp);
   
   return(0);
}

int fputs(const char *str, FILE *stream)

void perror(const char *str)

// 写文件步骤如下
// 1. 包含头文件
#include<fstream>
// 2. 创建流对象
ofstream ofs;
// 3. 打开文件
ofs.open("文件路径", 打开方式);
// 4. 写数据
ofs << "写入的数据";
// 5. 关闭文件
ofs.close();

// 1. 包含头文件
#include<fstream>
// 2. 创建流对象
ifstream ifs;
// 3. 打开文件并判断文件是否打开成功
ifs.open("文件路径", 打开方式);
// 4. 读数据
// 四种读取方式
// (1).
char buf[1024] = { 0 };
while(ifs >> buf) {
    cout << buf << endl;
}
// (2).
char buf[1024] = { 0 };
while(ifs.getline(buf, sizeof(buf))){
    cout << buf << endl;
}
// (3).
string ifs;
while(getline(ifs, buf)){
	cout << buf << endl; 
}
// (4).
char c;
while((c = ifs.get()) != EOF) {		
    // 	EOF:the end of file
    cout << c;
}
// 5. 关闭文件
ifs.close();

#include <iostream>
#include <stdlib.h>
int heanm(int m, int n);
int heanm(int m, int n) {
	if (m == n) {
		std::cout << "the function is a error\n";
		abort();
		// exit(int status);
	}
	return m / (m - n);
}
int main() {
	int m = 10, n = 10;
	return 0;
}
/*
/* output:
/* the function is a error
/* abnormal program termination
*/

if (b == 0) {
    throw "i like you~";
}

// 捕获固定异常
try {
    // 要监测的代码段，其中必须有抛出一个错误选择的异常
} catch(const char* error) {	// arguement要和抛出异常的类型相匹配
    cout << error << endl;
}
// 捕获任意异常
try {
    // 监测代码段
} catch(...) {	// 通用性较强
    cout << "error" << endl;
}

int test01(int m, int b) {
    if (b == 0) throw "fool";
    return m/b;
}
int main() {
    try {
        int ret = test01(10, 0);
        std::cout << ret << std::endl;
    } 
    catch (int e) {
        std::cerr << e << std::endl;
    }
    catch (float e) {
        std::cerr << e << std::endl;
    }
    catch (const char* e) {
        std::cout << e << std::endl;
    }
    return 0;
}
// 输出：fool

#include <stdexcept>
class logic_error: public exception {
public:
	explicit logic_error(const string& what_arg);
...
};
class domain_error: public exception {
public:
	explicit domain_error(const string& what_arg);
...
};
// 每个类都有一个类似于logic_error的构造函数，提供一个供方法what()返回的字符串

try {
	...
} catch(out_of_bounds& oe) {
	...// catch out_of_bounds error
} catch(logic_error& oe) {
	...// catch remaining logic_error family
} catch(exception& oe) {
	...// catch runtime_error, exception obects
}

#include <new>
#include <iostream>
#include <cstdlib>
using namespace std;

struct Big {
	double stuff[20000];
};
int main() {
	Big *pb; 
	try {
		cout << "Trying to get a big block of memory\n"; 
		pb = new Big[10000];
		cout << "Got past the new request:\n";
	} catch(bad_alloc &ba) {
		cout << "Get the exception!\n";
		cout << ba.what() << endl;
		exit(EXIT_FAILURE);
	}
	cout << "Menory successfully allocated\n";
	pb[0].stuff[0] = 4;
	cout << pb[0].stuff[0] << endl;
	delete [] pb;
	return 0;
}

/*
/*Trying to get a big block of memory
/*Get the exception!
/*std::bad_alloc
*/

int *p = new (std::nothrow) int;
int *pp = new (std::nothrow) int[500];
// 可将上一个例子的代码改为
Big *pb;
pb = new (std::nothrow) Big[10000];
if (pb == 0) {
	cout << "Could not allocate memory, Bye\n" << endl;
	exit(EXIT_FAILURE);
}

void func() {}		// 此时可以抛出任何异常

void func() throw (int, char, char*) {}		// 指定抛出异常

// 此时他只能抛出int, char, char*类型的异常
void test01() throw(int, char, char*) {
    throw 10;
}
int main() {
    try {
        test01();
    }
    catch(int e) {
        std::cerr << e << std::endl;
    }
    return 0;
}

void func() onexcept {}

// 设计一个圆类，求圆的周长
#include<iostream>
using namespace std;

const double PI = 3.14;
class Circle{
    // 访问权限
    public:
    // 属性
    int m_r;
    // 行为
    // 获取圆的周长
    double calculateZC() {
        return 2 * PI * m_r;
    };
};
int main() {
    // 通过圆类创建一个具体的圆
    Circle cl;
    // 给圆对象的属性进行赋值
    cl.m_r = 10;
    cout << "周长为" << cl.calculateZC() << endl;
    system("pause");
    return 0;
}

class Person {
    public:
    	string m_Car;
    protected:
    	int m_P;
    private:
    	int m_S;
}

#include<iostream>
using namespace std;

class Person {
public:
	// 构造函数：用于初始化类
	Person() {
		cout << "sd" << endl;
	}
	// 析构函数
	~Person() {
		cout << "sad" << endl;
	}
    /*
    	~Cat() {
		if (m_Name != NULL) {
			delete m_Name;
			m_Name = NULL;
		}
	}
    */

};
void test01() {
	Person p;		// 对象的初始化操作
}
int main() {
	test01();
	system("pause");
	return 0;
}

class Person {
public:
	// 无参构造
	Person() {
		cout << "a" << endl;
	}

class Person {
public:
	// 有参构造
	Person(int a) {
		age = a;
		cout << "a" << endl;
	}

class student {
	public:
		int age;
		student(int m): age(m) {}
}
int main(void) {
	student s(10);		// 1 正常写法 通过
	student s1 = 10;	// 2 通过
}

student s;
student s1(20);
int n = 10;
s = s1;		// 这样是一个拷贝
s = n;		// 这样就把一个int转换成了一个student对象

class stu {
	public:
		// 此处不能为此函数指定返回值类型，因为其返回值类型基本上已经表现欲函数名称上
		operator int() const;
}
int main(void) {
	stu r(1, 2);
	int d = 5 * r;
	return 0;
}

class student {
	public:
		int age;
		explicit student(int m): age(m) {}
}
int main(void) {
	student s(10);		// 1 正常写法，通过
	// student s1 = 10;	// 2 错误，不通过
}

class Person {
public:
	// 拷贝（copy）构造
	Person(const Person &p) {
		// 将传入的人身上所有属性(age)拷贝到我身上
		age = p.age;
	}

class Person {
public:
	// 拷贝（copy）构造
	Person(const Person &&p) : age(p.age){
		p.age = nullptr;
	}

#include<iostream>
using namespace std;

// 1. 构造参数的分类和调用
/* 按照参数分类：无参构造(默认构造)和有参构造
	按照类型分类：普通构造和拷贝构造
*/
class Person {
public:
	// 无参构造
	Person() {
		cout << "a" << endl;
	}
	// 有参构造
	Person(int a) {
		age = a;
		cout << "a" << endl;
	}
	// 拷贝（copy）构造
	Person(const Person &p) {
		// 将传入的人身上所有属性拷贝到我身上
		age = p.age;
	}
	~Person() {
		cout << "b" << endl;
	}
	int age;
};

// 调用
void test01() {
	// 括号法
	Person p1;		// 默认构造函数
	Person p2(10);		// 有参构造
	Person p3(p2);		// 拷贝(有参)构造
	// 显示法
	Person p1;		// 默认构造
	Person p2 = Person(10);		// 有参构造
	Person p3 = Person(p2);		// 拷贝构造
	// 隐式转换法
	Person p4 = 10;	// Person p4 = Person(10);
	Person p5 = p4;		// 拷贝构造
};
int main() {
	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

// 拷贝构造函数调用时机

class Person {
public:
	// 构造函数
	Person() {
		cout << "a" << endl;
	}
	Person(int age) {
		m_age = age;
		cout << "a" << endl;
	}
	Person(const Person& p) {
		m_age = p.m_age;
		cout << "a" << endl;
	}
	// 析构函数
	~Person() {
		cout << "b" << endl;
	}
	int m_age;
};
// 1. 使用一个已经创建完毕的对象来初始化一个对象
void test01() {
	Person p1(20);
	Person p2(p1);
}
// 2. 值传递的方式给函数参数传值
void dowe(Person p) {

}
void test02() {
	Person p;
	dowe(p);
}
// 3. 以值方式返回局部对象
void dowe2() {
	Person p1;
	return p1;
}
void test03() {
	Person p = dowe2();		// 此时的p不是dowe2传递的p1,地址不同但是值相同
}
int main() {
	test01();
	test02();
	test03();
	system("pause");
	return 0;
}

#include<iostream>
using namespace std;
// 初始化列表
class Person {
public:
	// 传统的初始化操作
	Person(int a, int b, int c) {
		m_A = a;
		m_B = b;
		m_C = c;
	}
	// 初始化列表操作初始化属性
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {

	}
	int m_A;
	int m_B;
	int m_C;
};
void test01() {
	Person p(10, 20, 30);
	cout << p.m_A;
	cout << p.m_B;
	cout << p.m_C;
	cout << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

class A {}
class B {
    A a;		// B类中有对象A作为成员，A为对象成员
}

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

// 手机类 
class Phone {
public:
	Phone(string m_name) {
		m_name = m_name;
	}
	string m_name;
};
// 人类
class Person {
public:
	Person(string name, string m_name): name(name), m_Phone(m_name)
	{

	}
	string name;
	Phone m_Phone;
};
void test01() {
	Person p("张三", "apple");
}
int main() {
	test01();
	system("pause");
	return 0;
}

int Person::m_A = 0;		// 静态成员变量，类外初始化

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

class Person {
public:
	// 静态成员函数
	static void func() {
		m_A = 100;		// 静态成员函数可以访问静态成员变量
		// m_B = 200,报错，静态成员函数不可以访问非静态成员变量
		cout << "sad" << endl;
	}
	static int m_A;		// 静态成员变量，类内声明
};
int Person::m_A = 0;		// 静态成员变量，类外初始化
// 有两种访问方式
void test01() {
	// 1. 通过对象访问
	Person p;
	p.func();
	// 2. 通过类名访问
	Person::func();
}
int main() {
	test01();
	system("pause");
	return 0;
}

#include <iostream>
using namespace std;
class Person {
public:
    Person(int age) {
        // this指针指向被调用的成员函数所属的对象
        this ->age = age;  
        // 当形参和成员变量同名时，可以用this指针来区分
        // 此时this ->age表示的是成员变量int age
    }
    int age;
};
// 解决名称冲突
void test01() {
    Person p1(18);
    cout << p1.age << endl;
}
// 返回对象本身用*this
void test02() {
    Person p1(10);
    Person p2(10);
    cout << p1.age << endl;
}
int main()
{
    test01();
    test02();
    cout << "Hello World!" << endl;
}

// 成员变量默认前面加了个this

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

// 建筑物类
class Building {
	// goodgay全局函数是building的好朋友，可以访问building私有成员
	friend void goodgay(Building* building);
public:
	Building() {
		m_sittingroom = "客厅";
		m_bedroom = "卧室";
	}
public:
	string m_sittingroom;	// 客厅
private:
	string m_bedroom;		// 卧室
};
// 全局函数
void giidgay(Building *building) {
	cout << building->m_sittingroom << endl;
}
void test01() {
	Building building;
	giidgay(&building);
}
int main() {
	system("pause");
	return 0;
}

#include <iostream>
using namespace std;
 
class Distance
{
   private:
      int feet;             // 0 到无穷
      int inches;           // 0 到 12
   public:
      // 所需的构造函数
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      // 显示距离的方法
      void displayDistance()
      {
         cout << "F: " << feet << " I:" << inches <<endl;
      }
      // 重载负运算符（ - ）
      Distance operator- ()  
      {
         feet = -feet;
         inches = -inches;
         return Distance(feet, inches);
      }
};
int main()
{
   Distance D1(11, 10), D2(-5, 11);
 
   -D1;                     // 取相反数
   D1.displayDistance();    // 距离 D1
 
   -D2;                     // 取相反数
   D2.displayDistance();    // 距离 D2
 
   return 0;
}

#include <iostream>
using namespace std;
 
class Box
{
   double length;      // 长度
   double breadth;     // 宽度
   double height;      // 高度
public:
 
   double getVolume(void)
   {
      return length * breadth * height;
   }
   void setLength( double len )
   {
       length = len;
   }
 
   void setBreadth( double bre )
   {
       breadth = bre;
   }
 
   void setHeight( double hei )
   {
       height = hei;
   }
   // 重载 + 运算符，用于把两个 Box 对象相加
   Box operator+(const Box& b)
   {
      Box box;
      box.length = this->length + b.length;
      box.breadth = this->breadth + b.breadth;
      box.height = this->height + b.height;
      return box;
   }
};
// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1，类型为 Box
   Box Box2;                // 声明 Box2，类型为 Box
   Box Box3;                // 声明 Box3，类型为 Box
   double volume = 0.0;     // 把体积存储在该变量中
 
   // Box1 详述
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // Box2 详述
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // Box1 的体积
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // Box2 的体积
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;
 
   // 把两个对象相加，得到 Box3
   Box3 = Box1 + Box2;
 
   // Box3 的体积
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;
 
   return 0;
}

#include <iostream>
using namespace std;
 
class Distance
{
   private:
      int feet;             // 0 到无穷
      int inches;           // 0 到 12
   public:
      // 所需的构造函数
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      // 显示距离的方法
      void displayDistance()
      {
         cout << "F: " << feet << " I:" << inches <<endl;
      }
      // 重载负运算符（ - ）
      Distance operator- ()  
      {
         feet = -feet;
         inches = -inches;
         return Distance(feet, inches);
      }
      // 重载小于运算符（ < ）
      bool operator <(const Distance& d)
      {
         if(feet < d.feet)
         {
            return true;
         }
         if(feet == d.feet && inches < d.inches)
         {
            return true;
         }
         return false;
      }
};
int main()
{
   Distance D1(11, 10), D2(5, 11);
 
   if( D1 < D2 )
   {
      cout << "D1 is less than D2 " << endl;
   }
   else
   {
      cout << "D2 is less than D1 " << endl;
   }
   return 0;
}

#include <iostream>
using namespace std;
 
class Distance
{
   private:
      int feet;             // 0 到无穷
      int inches;           // 0 到 12
   public:
      // 所需的构造函数
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      void operator=(const Distance &D )
      { 
         feet = D.feet;
         inches = D.inches;
      }
      // 显示距离的方法
      void displayDistance()
      {
         cout << "F: " << feet <<  " I:" <<  inches << endl;
      }
      
};
int main()
{
   Distance D1(11, 10), D2(5, 11);
 
   cout << "First Distance : "; 
   D1.displayDistance();
   cout << "Second Distance :"; 
   D2.displayDistance();
 
   // 使用赋值运算符
   D1 = D2;
   cout << "First Distance :"; 
   D1.displayDistance();
 
   return 0;
}

#include <iostream>
using namespace std;
 
class Time
{
   private:
      int hours;             // 0 到 23
      int minutes;           // 0 到 59
   public:
      // 所需的构造函数
      Time(){
         hours = 0;
         minutes = 0;
      }
      Time(int h, int m){
         hours = h;
         minutes = m;
      }
      // 显示时间的方法
      void displayTime()
      {
         cout << "H: " << hours << " M:" << minutes <<endl;
      }
      // 重载前缀递增运算符（ ++ ）
      Time operator++ ()  
      {
         ++minutes;          // 对象加 1
         if(minutes >= 60)  
         {
            ++hours;
            minutes -= 60;
         }
         return Time(hours, minutes);
      }
      // 重载后缀递增运算符（ ++ ）
      Time operator++( int )         
      {
         // 保存原始值
         Time T(hours, minutes);
         // 对象加 1
         ++minutes;                    
         if(minutes >= 60)
         {
            ++hours;
            minutes -= 60;
         }
         // 返回旧的原始值
         return T; 
      }
};
int main()
{
   Time T1(11, 59), T2(10,40);
 
   ++T1;                    // T1 加 1
   T1.displayTime();        // 显示 T1
   ++T1;                    // T1 再加 1
   T1.displayTime();        // 显示 T1
 
   T2++;                    // T2 加 1
   T2.displayTime();        // 显示 T2
   T2++;                    // T2 再加 1
   T2.displayTime();        // 显示 T2
   return 0;
}

#include <iostream>
using namespace std;
 
class Distance
{
   private:
      int feet;             // 0 到无穷
      int inches;           // 0 到 12
   public:
      // 所需的构造函数
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      friend ostream &operator<<( ostream &output, 
                                       const Distance &D )
      { 
         output << "F : " << D.feet << " I : " << D.inches;
         return output;            
      }
 
      friend istream &operator>>( istream  &input, Distance &D )
      { 
         input >> D.feet >> D.inches;
         return input;            
      }
};
int main()
{
   Distance D1(11, 10), D2(5, 11), D3;
 
   cout << "Enter the value of object : " << endl;
   cin >> D3;
   cout << "First Distance : " << D1 << endl;
   cout << "Second Distance :" << D2 << endl;
   cout << "Third Distance :" << D3 << endl;
 
 
   return 0;
}

#include <iostream>
using namespace std;
 
class Distance
{
   private:
      int feet;             // 0 到无穷
      int inches;           // 0 到 12
   public:
      // 所需的构造函数
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      // 重载函数调用运算符
      Distance operator()(int a, int b, int c)
      {
         Distance D;
         // 进行随机计算
         D.feet = a + c + 10;
         D.inches = b + c + 100 ;
         return D;
      }
      // 显示距离的方法
      void displayDistance()
      {
         cout << "F: " << feet <<  " I:" <<  inches << endl;
      }
      
};
int main()
{
   Distance D1(11, 10), D2;

   cout << "First Distance : "; 
   D1.displayDistance();

   D2 = D1(10, 10, 10); // invoke operator()
   cout << "Second Distance :"; 
   D2.displayDistance();

   return 0;
}

#include <iostream>
using namespace std;

// 继承实现页面
// 继承的好处，减少重复的代码
class Base {
public:
	void header() {
		cout << "a" << endl;
	}
};
class Java : public Base {
public:
	void content() {
		cout << "as" << endl;
	}
};
int main() {
	system("pause");
	return 0;
}

/*
公共继承：public：private不可继承
保护继承：protected：private不可继承
私有继承：private：
*/

#include<iostream>
using namespace std;
// 继承中同名成员处理
class Base {
public:
	Base() {
		m_A = 100;
	}
	void func() {
		cout << "asa" << endl;
	}
	void func(int a) {
		cout << "asa" << endl;
	}
	int m_A;
};
class Son :public Base {
public:
	Son() {
		m_A = 10;
	}
	void func() {
		cout << "asa" << endl;
	}
	int m_A;
};
// 同名成员属性
void test01() {
	Son s;
	cout << s.Base::m_A << endl;	// 加一个作用域
}
// 同名成员函数
void test02() {
	Son s;
	s.Base::func();
	// 如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类的同名成员
	s.Base::func(100);
}
int main() {
	system("pause");
	return 0;
}

#include<iostream>
using namespace std;
class Animal {
public:
	// virtual修饰的函数表示虚函数
	virtual void speak() {
		cout << "aa" << endl;
	}
};
class cat :public Animal {
public:
	void speak() {
		cout << "asa" << endl;
	}
};
// 执行说话的函数
// 地址早绑定 在编译阶段确定函数地址
// 如果想执行cat说话 地址近不能提前绑定


/* 
动态多态满足条件
	1. 有继承关系
    2. 子类重写父类的虚函数
动态多态使用
父类的指针或者引用 执行子类对象
重写：函数有返回值类型 函数名 参数列表 完全一致称为重写
*/
void dospeak(Animal& animal) {	// Animal& animal = cat
	animal.speak();
}
void test01() {
	cat cat;
	dospeak(cat);
}
int main() { 
	system("pause");
	return 0;
}

class C1 {
	public:
		C1();
		virtual ~C1();
		virtual void f1();
		virtual int f2(char c) const;
		virtual void f3(const string& s);
		void f4() const;
};

class C2:public C1 {
	public:
		C2();
		virtual ~C2();
		virtual void f1();
		virtual void f5(char* str);
		...		
};

#include <iostream>
using std::cout;
using std::endl;
class animal {
    public:
        animal(){}
        virtual void showname() {}
        virtual void eat() {}
        virtual ~animal() {}
};
class cat: public animal {
    public:
        cat() {}
        ~cat() {};
        virtual void show() {
            cout << "cat" << endl;
        }
        virtual void eat() {
            cout << "fish" << endl;
        }
};
int main() {
    animal* a = new animal();
    cat* b = new cat();
    cout << sizeof(a) << endl;
    cout << sizeof(b) << endl;
    return 0;
}
// output
// 8 8

class A {...};
class B:virtual public A {...};
class C:virtual public B {...};
class D:public B, public C {...};

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

class Animal {
public:
	// 纯虚函数
	virtual void speak() = 0;		// 只要是纯虚函数，都是抽象类
};
class Cat :public Animal {
public:
	Cat(string name) {
		m_Name = new string(name);

	}
	virtual void speak() {
		cout << "asa" << endl;
	}
    /* virtual ~Animal()		// 虚析构
    {
     	cout << "as" << endl;  
    }*/
    /*
    virtual ~Animal() = 0		// 纯虚析构
    全局函数
    Animal ::~Animal()
    {
    
    }
    */
	~Cat() {
		if (m_Name != NULL) {
			delete m_Name;
			m_Name = NULL;
		}
	}
	string *m_Name;
};
void test01() {
	Animal *animal = new Cat("muqier");
	animal->speak();
	// 父类指针在析构时候，不会调用子类中析构函数，导致子类如果有堆区属性，出现内存泄漏
	delete animal;
}
int main() { 
	system("pause");
	return 0;
}