C++零散笔记（供自学，如有错误望批评指正）

override是伪代码，所以是可写可不写的．它表示方法重写，写上会给我们带来好处．
　　　1．可以当注释用,方便阅读．
　　　2．告诉阅读你代码的人，这是方法的复写．
　　　3．编译器可以给你验证override左面的方法名是否是你父类中所有的，如果没有则报错．

class MyWork :public QRunnable
{
    Q_OBJECT
public:
    explicit MyWork();
    ~MyWork();

    void run() override;

}

class MyWork : public QObject, public QRunnable
{
    Q_OBJECT
public:
    explicit MyWork(QObject *parent = nullptr)
    {
        // 任务执行完毕,该对象自动销毁
        setAutoDelete(true);
    }
    ~MyWork();

    void run() override{}

}

在上面的示例中 MyWork 类是一个多重继承，如果需要在这个任务中使用 Qt 的信号槽机制进行数据的传递就必须继承 QObject 这个类，如果不使用信号槽传递数据就可以不继承了，只继承 QRunnable 即可。

• 变量别名

  1. 1. typedef unsigned int uint_t;
     2. using uint_t=unsigned int;
     

• 函数指针

  1.typedef int(*func_ptr)=(int,double);
  
  2.using func_ptr=int(*)(int,double);
  

• 模板别名

  //在C++98中，用tyhpedef定义别名只能用过一个外敷类实现
  
  1. template
  2. struct map_str_int    // 外敷类
  3. {
  4. ​	typedef std::map type;
  5. };
  6.  
  7. map_str_int::type map1;
  

  //在C++11中，用using重定义模板
  
  template
  
  using map_str_int = std::map; 
  
  map_str_int map1;
  

  函数指针

  1. 定义：与变量类似，每一个函数都占用一段内存单元，拥有一个起始地址（入口地址），指向该起始地址的指针被称作函数指针。

  2. 语法：数据类型（*指针变量名）（参数表），数据类型指函数的返回值类型，如：

     int (*p)(int a, int b); //p是一个指向函数的指针变量，所指函数的返回值类型为整型
     
     int *p(int a, int b); //p是函数名，此函数的返回值类型为整型指针
     

     • 在给函数指针变量赋值时，只需给出函数名，而不必给出参数。

       int max(int x, int y); 
       
       int (*p)(int a, int b);
       
       p = max;
       

     • 在一个程序中，指针变量p可以先后指向不同的函数，但一个函数不能赋给一个不一致的函数指针（即不能让一个函数指针指向与其类型不一致的函数）。

       如有如下的函数：int fn1(int x, int y); int fn2(int x);
       
       定义如下的函数指针：int (*p1)(int a, int b); int (*p2)(int a);
       
       则
       
       p1 = fn1; //正确
       
       p2 = fn2; //正确
       
       p1 = fn2; //产生编译错误
       

3. 应用

   • 函数指针变量常用的用途之一是把指针作为参数传递到其他函数。

     #include 
     using namespace std;
     #include 
     
     int max(int x, int y); //求最大数
     int min(int x, int y); //求最小数
     int add(int x, int y); //求和
     void process(int i, int j, int (*p)(int a, int b)); //应用函数指针
     
     int main()
     {
     	int x, y;
     	cin>>x>>y;
     
     	cout<<"Max is: ";
     	process(x, y, max);
     	 
     	cout<<"Min is: ";
     	process(x, y, min);
     	 
     	cout<<"Add is: ";
     	process(x, y, add);
     	 
     	getch();
     	return 0;
     
     }
     
     int max(int x, int y)
     {
     	return x > y ? x : y;
     }
     
     int min(int x, int y)
     {
     	return x > y ? y : x;
     }
     
     int add(int x, int y)
     {
     	return x + y;
     }
     
     void process(int i, int j, int (*p)(int a, int b))
     {
     	cout< 条件编译的使用 
     在头文件中引入条件编译，防止该头文件重复编译引发错误
      
      

位于头文件的代码一般来说不应该使用using声明，这是因为头文件的内容会拷贝到所有引用他的文件中去，如果头文件里有某个using声明，那么每个使用了该头文件的文件就会都有这个声明，对于某些程序来说，由于不经意间包含了一些名字，反而会产生始料未及的冲突。

标准异常类库：

• 标准异常类：标准库中提供了很多异常类，通过类继承组织起来

1. try-catch

#include 
#include
#include
using namespace std;
int main()
{
	int item1,item2;
	while(cin>>item1>>item2)
	{
		try{//将可能引发异常的方法或代码段放到try语句块中
			if(item1==item2)
				cout<>c;
				if(!cin||c=='n')
					break;		
		}
	}
	return 0;
}

2. 特性

   跨函数？？？

   逐级上抛，直到遇到异常处理语句，若不存在用户级别的异常处理，程序便会异常结束

   异常捕捉严格按照类型匹配：throw一个对象或变量要用类或数据类型接。

   class A{};
   class B{};
   int main()
   {
       try{
           int j = 0; 
           double d = 2.3; 
           char 
           str[20] = "Hello";
           cout<<"Please input a exception number: ";
           int a; 
           cin>>a;
           switch(a){
               case 1: 
               throw d; 
               case 2: 
               throw j; 
               case 3: 
               throw str;
               case 4: 
               throw A(); 
               case 5: 
               throw B();
               default: 
               cout<<"No throws here.n"; 
           } 
       }
       catch(int){
       	cout<<"int exception.n";
       }
       catch(double){
       	cout<<"double exception.n";
       }
       catch(char*){
       	cout<<"char* exception.n";
       }
       catch(A){
       	cout<<"class A exception.n";
       }
       catch(B){
       	cout<<"class B exception.n";
       }
           cout<<"That's ok.n";
           system("pause");
   }
   

3. 异常接口声明

   “abcd”是char*类型的变量，或理解为数组指针

   可同时throw多种类型的异常，catch()为捕获所有类型的异常

   • 抛出捕获一个异常类

     class MyException
     {
     public:
     	MyException(char *str)
     	{
     		error=new char[strlen(str)+1];//在拷贝前先开辟/指定内存空间
     		strcpy(error,str);//将错误信息拷贝到内存空间中
     	}
     	MyException(const MyException& ex)//复制构造函数
     	{
     		this->error=new char[strlen(str)+1];
     		strcpy(this->error,ex.error);
     	}
     	MyException& operator=(const MyException& ex)//赋值操作符重载
     	{
     		if(this->error!=NULL)
     		{
     			delete[] error;
     			this->error=NULL;
     		}
     		this->error=new char[strlen(str)+1];
     		strcpy(this->error,ex.error);
     	}
     	void what()
     	{
     		cout<error=NULL;
     		}
     	}
     protected:
     	char *error;
     };
     throw MyException("异常类型");//调用构造函数，生成匿名对象，抛出匿名对象
     catch(MyException e)//若直接调用拷贝构造，e与匿名对象的error会指向同一块内存空间，导致两次析构，其实也可以把char换成string，用不到指针也就没这么多麻烦，或者用& e？？？
     {
     	e.what();
     }
     

4. C++的标准异常类

   建议自己的异常类要继承标准异常类

计算机科学中，健壮性（英语：Robustness）是指一个计算机系统在执行过程中处理错误，以及算法在遭遇输入、运算等异常时继续正常运行的能力。 诸如模糊测试之类的形式化方法中，必须通过制造错误的或不可预期的输入来验证程序的健壮性。

类交叉包含时用前向声明/前置声明

# include//对可见域的操作
#include//对文件进行的操作
#include//对内存的操作

c的强制类型转换：不管什么类型，都是Type b=(Type)a;

C++的类型转换：（cast———投掷）

• static_cast 静态类型转换。如 int 转换成 char

  用于内置数据类型与具有继承关系的指针或引用（子转父与父转子都行）

• reinterpreter_cast 重新解释类型

• dynamic_cast 命名上理解是动态类型转换。如子类和父类之间的多态类型转换，会进行安全检查。子类指针可以转换为父类指针（由大到小），转换后的类型安全

• const_cast 字面上理解就是去 const 属性。

4 种类型转换的格式：

TYPE B = static_cast (a)

函数参数中使用const

const char*, char const*, char*const的区别

• 指针常量：数据类型 * const 指针变量=变量名；

  指向不能修改，指向的值可以修改

• 常量指针：const 数据类型 *指针变量=变量名；

  指向常量的指针变量，指向可以修改，指向的值不能修改

• 常指针常量：const 数据类型 * const 指针变量=变量名；

  指针不能改变，指针指向的值也不能改变

  char *q;
  const char * const p="ABCDEF";//定义了一个常量常指针
  q=p;//错误，试图讲一个常指针赋值给非常指针
  p=q;//错误，试图修改指针常量的值，如1
  *p=‘1’；//错误，试图修改指针指向的值，如2
  p[1]='1';//错误，如2
  p=NULL；//错误，如1
  

1. 继承方式，属性

2. 构造函数赋初值

   // 单链表
   struct ListNode {
       int val;  // 节点上存储的元素
       ListNode *next;  // 指向下一个节点的指针
       ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
   };
   

​ ：相当于val=x,next=NULL