WHCSRL 技术网

C++异常处理机制（超级详细）

目录

0.异常处理机制简介

1.传统错误处理机制（通过函数返回值）

2.异常处理机制语法 

​3.异常接口声明

4.异常类型和声明周期

4.1throw基本类型异常（int 、float、char.....）

4.2throw字符串类型异常

​ 4.3throw类对象类型异常

4.3.1第一种：抛出匿名对象，使用形参接收

​4.3.2第二种： 抛出局部变量，使用形参接收

4.3.3第三种：抛出匿名对象，使用引用接收（代码优化 ）

5.异常和继承

6. 额外补充——标准库里的异常类

0.异常处理机制简介

异常无处不在，程序随时可能误入歧途！C++ 提出了新的异常处理机制！

异常是一种程序控制机制，与函数机制互补。

函数是一种以栈结构展开的上下函数衔接的程序控制系统,异常是另一种控制结构,它可以在出现“意外”时中断当前函数,并以某种机制（类型匹配）回馈给隔代的调用者相关的信息。

 图像示例：

当C函数发生错误时，不需要将错误一级级 返回给main，利用异常，直接返回给main：

1.传统错误处理机制（通过函数返回值）

需求： 实现文件的二进制拷贝（当希望文件能够原封不动的拷贝时，要用二进制拷贝）

将要拷贝文件：

代码实现：

  1. // demo 15-14  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4.  
  5. #define BUFSIZE 1024
  6.  
  7. //实现文件的二进制拷贝
  8. int copyfile(const char* dest, const char* src) {
  9. 	FILE* fp1 = NULL, * fp2 = NULL;
  10.  
  11. 	//rb 只读方式打开一个二进制文件，只允许读取数据
  12. 	fopen_s(&fp1, src, "rb");
  13.  
  14. 	if (fp1 == NULL) {
  15. 		return -1;
  16. 	}
  17.  
  18. 	//wb 以只写的方式打开或新建一个二进制文件，只允许写数据。
  19. 	fopen_s(&fp2, dest, "wb");
  20. 	if (fp2 == NULL) {
  21. 		return -2;
  22. 	}
  23.  
  24. 	char buffer[BUFSIZE];
  25. 	int readlen, writelen;
  26.  
  27. 	//如果读到数据，则大于0
  28. 	while ((readlen = fread(buffer, 1, BUFSIZE, fp1)) > 0) {
  29. 		writelen = fwrite(buffer, 1, readlen, fp2);
  30. 		if (readlen != writelen) {
  31. 			return -3;
  32. 		}
  33. 	}
  34.  
  35. 	fclose(fp1);
  36. 	fclose(fp2);
  37. 	return 0;
  38. }
  39.  
  40. void main() {
  41. 	int ret = 0;
  42.     //temp.txt为要拷贝的文件，CopyTemp.txt为拷贝文件
  43. 	ret = copyfile("CopyTemp.txt","temp.txt");
  44.  
  45. 	if (ret != 0) {
  46. 		switch (ret) {
  47. 		case -1:
  48. 			printf("打开源文件失败!
");
  49. 			break;
  50. 		case -2:
  51. 			printf("打开目标文件失败!
");
  52. 			break;
  53. 		case -3:
  54. 			printf("拷贝文件时失败!
");
  55. 			break;
  56. 		default:
  57. 			printf("出现未知的情况!
");
  58. 			break;
  59. 		}
  60. 	}
  61. 	system("pause");
  62. }

运行截图：

拷贝文档截图：  

当temp.txt文档不存在时，运行截图：

传统错误返回需要一层层返回错误，而异常处理可以直接到达能够处理异常的地方。

2.异常处理机制语法 

  1. 异常发生第一现场，抛出异常
  2. void  function( ){
  3.         //... ...
  4.           throw 表达式;
  5.         //... ...
  6. }
  7. 在需要关注异常的地方，捕捉异常
  8. try{
  9.         //程序
  10.         function();        把function至于try中
  11.         //程序
  12. }catch(异常类型声明){        比如只写一个int
  13.         //... 异常处理代码 ...
  14. }catch(异常类型 形参){       形参将会取得抛出的值
  15.         //... 异常处理代码 ...
  16. }catch(...){               抛出的其它异常类型，可以接收任意类型
  17.         //
  18. }
  19. 如果没有catch(...)，并且没有catch子句与抛出的异常类型匹配，程序会直接中断报错。

修改“文件的二进制拷贝”代码： 

  1. // demo 15-16  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string>
  5.  
  6. using namespace std;
  7.  
  8. #define BUFSIZE 1024
  9.  
  10. //实现文件的二进制拷贝
  11. int copyfile2(const char* dest, const char* src) {
  12. 	FILE* fp1 = NULL, * fp2 = NULL;
  13.  
  14. 	//通过throw操作创建一个异常对象并抛掷
  15. 	//rb 只读方式打开一个二进制文件，只允许读取数据
  16. 	fopen_s(&fp1, src, "rb");
  17.  
  18. 	if (fp1 == NULL) {
  19. 		throw new string("文件不存在");
  20. 	}
  21.  
  22. 	//wb 以只写的方式打开或新建一个二进制文件，只允许写数据。
  23. 	fopen_s(&fp2, dest, "wb");
  24. 	if (fp2 == NULL) {
  25. 		throw  0.01f;;
  26. 	}
  27.  
  28. 	char buffer[BUFSIZE];
  29. 	int readlen, writelen;
  30.  
  31. 	//如果读到数据，则大于0
  32. 	while ((readlen = fread(buffer, 1, BUFSIZE, fp1)) > 0) {
  33. 		writelen = fwrite(buffer, 1, readlen, fp2);
  34. 		if (readlen != writelen) {
  35. 			throw - 3;
  36. 		}
  37. 	}
  38.  
  39. 	fclose(fp1);
  40. 	fclose(fp2);
  41. 	return 0;
  42. }
  43.  
  44. //这种写法是将copyfile2的抛出异常给copyfile1，copyfile1再给main 
  45. int copyfile1(const char* dest, const char* src) {
  46. 	try {
  47. 		copyfile2(dest, src);
  48. 	}
  49. 	catch (float e) {
  50. 		//throw ;
  51. 		printf("copyfile1 - catch ...
");
  52.  
  53. 		//提示：处理不了的异常，我们可以在catch的最后一个分支，使用throw语法，继续向调用者throw。就比如再抛给main~
  54. 		throw;  //throw后面可以写接收到的e，也可以不写，不写的话会给出“未使用局部变量”的警告
  55. 	}
  56.  
  57. 	return 0;
  58. }
  59.  
  60. void main() {
  61. 	int ret = 0;
  62.  
  63. 	//在需要捕捉异常的地方，将可能抛出异常的程序段嵌在try块之中
  64. 	//按正常的程序顺序执行到达try语句，然后执行try块{}内的保护段
  65. 	//如果在保护段执行期间没有引起异常，那么跟在try块后的catch子句就不执行，程序从try块后跟随
  66.     //的最后一个catch子句后面的语句继续执行下去
  67. 	try {//保护段
  68. 		printf("开始执行 copyfile1...
");
  69. 		ret = copyfile1("CopyTemp.txt", "temp.txt");
  70. 		printf("执行 copyfile1 完毕
");
  71.  
  72. 		//catch子句按其在try块后出现的顺序被检查，匹配的catch子句将捕获并按catch子句中的代码
  73.         //处理异常（或继续抛掷异常）
  74. 	}
  75. 	catch (int error) {
  76. 		printf("出现异常啦！%%d
", error);
  77. 	}
  78. 	catch (string* error) {
  79. 		printf("捕捉到字符串异常：%%s
", error->c_str());
  80. 		delete error;
  81. 	}
  82. 	catch (float error) {
  83. 		printf("出现异常啦！%%f
", error);
  84. 	}
  85. 	catch (...) {
  86. 		printf("catch ...
");
  87. 	}
  88.  
  89.  
  90. 	//如果没有找到匹配，则缺省功能是调用abort终止程序。
  91.  
  92. 	system("pause");
  93. }

 注意：

1.throw后面可跟任何表达式，除了整数外，指针、字符常量等也可以，如：throw "文档打开失败"。

2.通过throw操作创建一个异常对象并抛掷

3.在需要捕捉异常的地方，将可能抛出异常的程序段嵌在try块之中

4.按正常的程序顺序执行到达try语句，然后执行try块{}内的保护段

5.如果在保护段执行期间没有引起异常，那么跟在try块后的catch子句就不执行，程序从try块后跟随的最后一个catch子句后面的语句继续执行下去

6.catch子句按其在try块后出现的顺序被检查，匹配的catch子句将捕获并按catch子句中的代码处理异常（或继续抛掷异常）

7.如果没有找到匹配，则缺省功能是调用abort终止程序。

运行结果：

当temp.txt文档不存在，运行结果：

3.异常接口声明

可以在函数声明中列出可能抛出的所有异常类型，加强程序的可读性。

如：

int copyfile2(char *dest, char *src) throw (float, string *, int)  { }

这样，在阅读代码时便可知这个函数会抛出float、string*和int类型异常，增加可读性

注意：

1.对于异常接口的声明，在函数声明中列出可能抛出的所有异常类型

2.如果没有包含异常接口声明，此函数可以抛出任何类型的异常

3.如果函数声明中有列出可能抛出的所有异常类型,那么抛出其它类型的异常讲可能导致程序终止（对于有些编译器可以抛出其它未在声明列表中的异常类型，如老式VC++）

4.如果一个函数不想抛出任何异常，可以使用 throw () 声明（有些编译器会警告throw()，如老式VC++）

4.异常类型和声明周期

4.1throw基本类型异常（int 、float、char.....）

  1. // demo 15-17
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string>
  5.  
  6. using namespace std;
  7.  
  8. #define BUFSIZE 1024
  9.  
  10.  
  11. //实现文件的二进制拷贝
  12.  
  13. //第一种情况，throw 普通类型，和函数返回传值是一样的
  14. int copyfile2(const char *dest, const char *src){
  15. 	FILE *fp1 = NULL, *fp2 = NULL;
  16.  
  17. 	//rb 只读方式打开一个二进制文件，只允许读取数据
  18. 	fopen_s(&fp1, src, "rb");
  19.  
  20. 	if(fp1 == NULL){
  21. 		//int ret = -1;
  22. 		char ret = 'a';
  23. 		throw ret;
  24. 	}
  25.  
  26. 	//wb 以只写的方式打开或新建一个二进制文件，只允许写数据。
  27. 	fopen_s(&fp2, dest, "wb");
  28. 	if(fp2 == NULL){
  29. 		throw -2;
  30. 	}
  31.  
  32. 	char buffer[BUFSIZE];
  33. 	int readlen, writelen;
  34.  
  35. 	//如果读到数据，则大于0
  36. 	while( (readlen = fread(buffer, 1, BUFSIZE, fp1)) > 0 ){
  37. 		writelen = fwrite(buffer, 1, readlen, fp2);
  38. 		if(readlen != writelen){
  39. 			throw -3 ;
  40. 		}
  41. 	}
  42.  
  43. 	fclose(fp1);
  44. 	fclose(fp2);
  45. 	return 0;
  46. }
  47.  
  48. int copyfile1(const char *dest, const char *src){
  49. 	return copyfile2(dest, src);
  50. }
  51.  
  52. void main(){
  53. 	int ret = 0;
  54.  
  55. 	
  56. 	try{//保护段
  57. 		//printf("开始执行 copyfile1...
");
  58. 		ret = copyfile1("CopyTemp.txt", "temp.txt");
  59. 		//printf("执行 copyfile1 完毕
");
  60. 			
  61. 	}catch(int error){
  62. 		printf("出现异常啦！%%d
", error);    //error周期只在此语句中
  63. 	}catch(char error){
  64. 		printf("出现异常啦！%%c
", error);    //error周期只在此语句中
  65. 	}
  66.  
  67. 	system("pause");
  68. }

对于基本类型异常，使用对应的类型 catch捕捉即可~。

4.2throw字符串类型异常

  1. // demo 15-18
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string>
  5.  
  6. using namespace std;
  7.  
  8. #define BUFSIZE 1024
  9.  
  10.  
  11. int copyfile3(const char* dest, const char* src) {
  12. 	FILE* fp1 = NULL, * fp2 = NULL;
  13.  
  14. 	//rb 只读方式打开一个二进制文件，只允许读取数据
  15. 	fopen_s(&fp1, src, "rb");
  16.  
  17. 	if (fp1 == NULL) {
  18. 		const char* error = "大佬，你的源文件打开有问题";
  19. 		printf("throw 前，error 的地址：%%p
", error);
  20. //第二种情况，throw 字符串类型，实际抛出的指针，而且，修饰指针的const 也要严格进行类型匹配
  21. 		throw error;  //常量字符串类型，返回的是个地址
  22. 	}
  23.  
  24. 	//wb 以只写的方式打开或新建一个二进制文件，只允许写数据。
  25. 	fopen_s(&fp2, dest, "wb");
  26. 	if (fp2 == NULL) {
  27. 		throw - 2;
  28. 	}
  29.  
  30. 	char buffer[BUFSIZE];
  31. 	int readlen, writelen;
  32.  
  33. 	//如果读到数据，则大于0
  34. 	while ((readlen = fread(buffer, 1, BUFSIZE, fp1)) > 0) {
  35. 		writelen = fwrite(buffer, 1, readlen, fp2);
  36. 		if (readlen != writelen) {
  37. 			throw - 3;
  38. 		}
  39. 	}
  40.  
  41. 	fclose(fp1);
  42. 	fclose(fp2);
  43. 	return 0;
  44. }
  45.  
  46. int copyfile1(const char* dest, const char* src) {
  47. 	return copyfile3(dest, src);
  48. }
  49.  
  50. void main() {
  51. 	int ret = 0;
  52.  
  53. 	try {//保护段
  54. 		//printf("开始执行 copyfile1...
");
  55. 		ret = copyfile1("CopyTemp.txt", "temp.txt");
  56. 		//printf("执行 copyfile1 完毕
");
  57.  
  58. 	}
  59. 	catch (int error) {
  60. 		printf("出现异常啦！%%d
", error);
  61. 	}
  62. 	catch (char error) {
  63. 		printf("出现异常啦！%%c
", error);
  64. 	}
  65. 	catch (string error) {
  66. 		printf("出现异常啦！%%s
", error.c_str());
  67. 	}
  68. //严格类型匹配，这里也需要加const
  69. 	catch (const char* error) {   //接收常量字符串类型异常地址
  70. 		printf("出现异常啦(char *)！%%s(地址：%%p)
", error, error);
  71. 	}
  72. 	catch (...) {
  73. 		printf("没捉到具体的异常类型
");
  74. 	}
  75.  
  76. 	system("pause");
  77. }

当抛出的异常类型为地址（指针）时候，catch捕捉类型也要为指针。并且，当抛出异常类型有const修饰时，捕捉类型也要有cosnt修饰。即严格类型匹配。

运行结果：

4.3throw类对象类型异常

当抛出的异常类型为一个类对象时： 

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string>
  4.  
  5.  
  6.  
  7. class ErrorException {
  8. public:
  9. 	ErrorException() {
  10. 		id = 0;
  11. 		printf("ErrorException  构造！
");
  12. 	}
  13.  
  14. 	~ErrorException() {
  15. 		printf("ErrorException  ~析构！(id: %%d)
", id);
  16. 	}
  17.  
  18. 	ErrorException(const ErrorException& e) {
  19. 		id = 1;
  20. 		printf("ErrorException  拷贝构造函数！
");
  21. 	}
  22.  
  23. 	int  id;
  24. };
  25.  
  26.

下面对throw语句进行分类研究： 

4.3.1第一种：抛出匿名对象，使用形参接收

  1.  
  2. throw ErrorException(); //抛出匿名对象
  3.  
  4. catch (ErrorException error) {
  5. 		printf("出现异常啦！捕捉到 ErrorException 类型 id: %%d
", error.id);
  6. }

运行结果：

4.3.2第二种： 抛出局部变量，使用形参接收

  1. ErrorException error1;
  2. throw error1; 
  3.  
  4. catch (ErrorException error) {
  5.         error.id=2;   //增加一句error.id=2，便于惯出
  6. 		printf("出现异常啦！捕捉到 ErrorException 类型 id: %%d
", error.id);
  7. }

运行结果：

由以上两种结果可得，不管是抛出匿名对象，还是抛出局部变量，程序都会生成一个匿名对象，并且，当catch是普通参数时，程序还要再次调用拷贝函数。 

4.3.3第三种：抛出匿名对象，使用引用接收（代码优化 ）

  1. throw ErrorException();   //直接抛出匿名对象
  2. 	
  3. catch (ErrorException& error) {   用引用方式来接
  4. 		//error.id = 2;
  5. 		printf("出现异常啦！捕捉到 ErrorException &类型 id: %%d
", error.id);
  6. }

 运行结果： 

当然也可以 动态分配内存，直接抛出指针，当然也要用指针接收。（严格类型匹配）

  1. throw new ErrorException();
  2.  
  3. catch (ErrorException* error) {
  4. 		printf("出现异常啦！捕捉到 ErrorException *类型 id: %%d
", error->id);
  5. 		delete error;
  6. }

运行结果：

 注意： 引用和普通的形参传值不能共存！

因为引用和普通形参都可以catch捕捉，编译器无法识别被哪个捕捉 。

5.异常和继承

异常也是类，我们可以创建自己的异常类，在异常中可以使用（虚函数，派生，引用传递和数据成员等）。

 案例：设计一个数组类容器 Vector，重载[]操作，数组初始化时，对数组的个数进行有效检查

1.index<0 抛出异常errNegativeException  

2.index = 0 抛出异常 errZeroException

3.index>1000抛出异常errTooBigException 

4.index<10 抛出异常errTooSmallException 

5.errSizeException类是以上类的父类，实现有参数构造、并定义virtual void printError()

Vector容器实现： 

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. class Vector{
  5. public:
  6. 	Vector(int length = 128); 
  7. 	int getLength();
  8. 	int& operator[](int index);
  9. 	~Vector();
  10. private:
  11. 	int*m_base;
  12. 	int m_length;
  13. };
  14.  
  15. Vector::Vector(int length) {
  16. 	m_length = length;
  17. 	m_base = new int[length];
  18. }
  19.  
  20. int Vector::getLength() {
  21. 	return m_length;
  22. }
  23.  
  24. //引用方式返回可以作为左值修改（即存储，Vector va(5);  va[1]=0）
  25. int& Vector::operator[](int index) {
  26. 	return m_base[index];
  27. }
  28.  
  29. Vector::~Vector() {
  30. 	if (m_base) {
  31. 		delete[] m_base;
  32. 		m_length = 0;
  33. 	}
  34. }

异常类实现： 

  1. class errNegativeException {
  2.  
  3. };
  4. class errZeroException {
  5.  
  6. };
  7. class errTooBigException {
  8.  
  9. };
  10. class errTooSmallException {
  11.  
  12. };

修改Vector的构造函数： 

  1. Vector::Vector(int length) {
  2. 	if (length < 0) {
  3. 		throw errNegativeException();
  4. 	}
  5. 	else if (length == 0) {
  6. 		throw errZeroException();
  7. 	}
  8. 	else if (length > 1000) {
  9. 		throw errTooBigException();
  10. 	}
  11. 	else if (length <= 10) {
  12. 		throw errTooSmallException();
  13. 	}
  14. 	m_length = length;
  15. 	m_base = new int[length]; 
  16. }

实现主函数接口： 

  1. int main() {
  2. 	try {
  3. 		Vector va(10);
  4. 		for (int i = 0; i < va.getLength(); i++) {
  5. 			va[i] = i + 3;
  6. 		}
  7. 	}
  8. 	catch (errNegativeException& erro) {
  9. 		cout << "errNegativeException" << endl;
  10. 	}
  11. 	catch (errZeroException& erro) {
  12. 		cout << "errZeroException" << endl;
  13. 	}
  14. 	catch (errTooBigException& erro) {
  15. 		cout << "errTooBigException" << endl;
  16. 	}
  17. 	catch (errTooSmallException& erro) {
  18. 		cout << "errTooSmallException" << endl;
  19. 	}
  20. 	
  21. 	system("pause");
  22. 	return 0;
  23. }

 运行结果：

 这种抛出异常方法跟直接return一个结果没啥两样，现在通过以前学习的虚函数进行代码优化： 

异常类代码优化：

  1. class errSizeException {
  2. public:
  3. 	errSizeException(int size) {
  4. 		m_size = size;
  5. 	}
  6. 	virtual void printErroe() {
  7. 		cout << "size:" << m_size << endl;
  8. 	}
  9. protected:
  10. 	int m_size;
  11. };
  12. //子类errNegativeException 
  13. class errNegativeException :public errSizeException {
  14. public:
  15. 	errNegativeException(int size) :errSizeException(size){}
  16. 	virtual void printErroe() {
  17. 		cout << "errNegativeException size:" << m_size << endl;
  18. 	}
  19. };
  20. //子类errZeroException 
  21. class errZeroException :public errSizeException {
  22. public:
  23. 	errZeroException(int size) :errSizeException(size) {}
  24. 	virtual void printErroe() {
  25. 		cout << "errZeroException size:" << m_size << endl;
  26. 	}
  27. };
  28. //子类errTooBigException 
  29. class errTooBigException :public errSizeException {
  30. public:
  31. 	errTooBigException(int size) :errSizeException(size) {}
  32. 	virtual void printErroe() {
  33. 		cout << "errTooBigException size:" << m_size << endl;
  34. 	}
  35. };
  36. //子类errTooSmallException 
  37. class errTooSmallException :public errSizeException {
  38. public:
  39. 	errTooSmallException(int size) :errSizeException(size) {}
  40. 	virtual void printErroe() {
  41. 		cout << "errTooSmallException size:" << m_size << endl;
  42. 	}
  43. };
  44.

父类是 errSizeException，子类继承父类。通过虚函数，实现子类代替父类。

主函数接口： 

  1.  
  2. int main() {
  3. 	try {
  4. 		Vector va(10);
  5. 		for (int i = 0; i < va.getLength(); i++) {
  6. 			va[i] = i + 3;
  7. 		}
  8. 	}
  9. 	catch (errSizeException& erro) {
  10. 		erro.printErroe();
  11. 	}
  12.  
  13. 	
  14. 	system("pause");
  15. 	return 0;
  16. }

运行结果：

6. 额外补充——标准库里的异常类

无需硬背，混个眼熟即可~

代码示例：

  1. #include <iostream>
  2. #include <exception>
  3. #include <stdexcept>
  4.  
  5. using namespace std;
  6.  
  7. class Student{
  8. public:
  9. 	Student(int age){
  10. 		if(age > 249){
  11. 			throw out_of_range("年龄太大，你是外星人嘛?");
  12. 		}
  13. 		m_age = age;
  14. 		m_space = new int[1024*1024*100];
  15. 	}
  16.  
  17. private :
  18. 	int m_age;
  19. 	int *m_space;
  20. };
  21.  
  22.  
  23. void main(){
  24.  
  25. 	try{
  26. 		for(int i=1; i<1024; i++){
  27. 			Student * xiao6lang = new Student(18);
  28. 		}
  29. 	}catch(out_of_range &e){
  30. 		cout<<"捕捉到一只异常："<<e.what()<<endl;
  31. 	}catch(bad_alloc &e){
  32. 		cout<<"捕捉到动态内存分配的异常："<<e.what()<<endl; 
  33. 	}
  34.  
  35. 	system("pause");
  36. }

运行结果：

推荐阅读

TypeError: unsupported operand type(s) for +: \'NoneType\' and \'str\'

遇到这个问题，因为在文件中写入中文，目前的做法是open时指定encoding为utf-8，问题解决。修改文件名为中文也有类似问题，原因是系统默认不支持中文。...

判断value非空以及非None

params = {k:v for k,v in data.items() if v}

vue3.x emit 用法_爱生活，爱编程的博客

child.vue&lt;template&gt; &lt;div&gt; &lt;p&gt;hello world&lt;/p&gt; &lt;button @click = "go" class="btn btn-success"&gt;go&lt;/button&gt; &lt;/div&gt;&lt;/template&gt;&lt;script lang="ts"&gt;import Vue from \'vue

bat批处理 tokens最大值31的修复_文哥博客的博客

@echo off&amp;setlocal enabledelayedexpansionset err=0for /f "delims=" %%a in ( "Letter\0Letter Small\0Tabloid\0Ledger\0Legal\0Statement\0Executive\0A3\0A4\0A4 Small\0A5\0B4 (JIS)\0B5 (JIS)\0Folio\0Quarto\010x14\011x17\0Note\0Envelope #9\0Envelope #1

iOS视频广告(一) GoogleAds-IMA-iOS-SDK

GoogleAds-IMA-iOS-SDK(谷歌纯视频广告SDK介绍 - iOS)开发开发环境: Xcode 7运行条件: iOS(9.0+)管理平台: admanger帐号。 https://admanager.google.com官网文档地址:https://developers.google.com/interactive-media-ads/docs/sdks/ios/...