当前位置： 首页 > news >正文

【C++进阶】C++11新特性上篇（万字详解）

news 来源：原创 2024/5/19 9:10:24

🎇C++学习历程：入门

  • 博客主页：一起去看日落吗
  • 持续分享博主的C++学习历程
  • 博主的能力有限，出现错误希望大家不吝赐教
  • 分享给大家一句我很喜欢的话： 也许你现在做的事情，暂时看不到成果，但不要忘记，树🌿成长之前也要扎根，也要在漫长的时光🌞中沉淀养分。静下来想一想，哪有这么多的天赋异禀，那些让你羡慕的优秀的人也都曾默默地翻山越岭🐾。

在这里插入图片描述

♠️ ♥️ ♣️ ♦️

目录

  • ♠️ 1. C++11简介
  • ♠️ 2. 列表初始化
    • ♥️ 2.1 {} 初始化
    • ♥️ 2.2 std::initializer_list
  • ♠️ 3. 声明
    • ♥️ 3.1 auto
    • ♥️ 3.2 decltype
    • ♥️ 3.3 nullptr
  • ♠️ 4. STL中一些变化
  • ♠️ 5. final 和 override
  • ♠️ 6. 右值引用和移动语义
    • ♥️ 6.1 左值引用和右值引用
    • ♥️ 6.2 左值引用和右值引用比较
    • ♥️ 6.3 右值引用使用场景和意义
    • ♥️ 6.4 左值引用使用场景
    • ♥️ 6.4 左值引用短板
    • ♥️ 6.5 右值引用和移动语义解决上述问题
    • ♥️ 6.6 STL容器插入接口函数也增加了右值引用版本

♠️ 1. C++11简介

相比C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率。

♠️ 2. 列表初始化

♥️ 2.1 {} 初始化

  • 在C++98中，标准允许使用花括号{}对数组元素进行统一的列表初始值设定。
struct Point
{
 	int _x;
 	int _y;
};
int main()
{
 	int array1[] = { 1, 2, 3, 4, 5 };
 	int array2[5] = { 0 };  //0 0 0 0 0 
 	Point p = { 1, 2 };  //运用了struct结构体的语法     初始化
 	return 0; 
 }
  • C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。
struct Point
{
	int _x;
	int _y;

	Point(int x, int y)
		:_x(x)
		, _y(y)
	{}
};

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	
	Point p = { 1, 2 };
	//Point p{ 1, 2 };
	
	Point* p3 = new Point[3]{ {1, 1}, { 2, 2 }, { 3, 3 } };

	int* p1 = new int(0);
	int* p2 = new int[5]{1,2,3,4,5};  
	//C++11中 new可以初始化数组

	//自定义类型的列表初始化
	Date d1(2022, 3, 13);
	Date d2 = { 2022, 3, 15 };
	Date d3{ 2022, 3, 15 };
	Date{2022,3,15};

	int i = 1;
	int j = { 2 };
	int k{ 3 };
	return 0;
}

♥️ 2.2 std::initializer_list

std::initializer_list介绍文档

  • std::initializer_list是什么类型
int main()
{
	// the type of il is an initializer_list
	auto il = { 10, 20, 30 };
	cout << typeid(il).name() << endl;
	return 0;
}

在这里插入图片描述

  • 模拟实现的vector支持{}初始化和赋值
template<class T>
class vector 
{
public:
	typedef T* iterator;
	vector(initializer_list<T> l)
	{
		_start = new T[l.size()];
		_finish = _start + l.size();
		_endofstorage = _start + l.size();
		iterator vit = _start;
		typename initializer_list<T>::iterator lit = l.begin();
		while (lit != l.end())
		{
			*vit++ = *lit++;
		}
		//for (auto e : l)
		//   *vit++ = e;
	}
	vector<T>& operator=(initializer_list<T> l) {
		vector<T> tmp(l);
		std::swap(_start, tmp._start);
		std::swap(_finish, tmp._finish);
		std::swap(_endofstorage, tmp._endofstorage);
		return *this;
	}
private:
	iterator _start;
	iterator _finish;
	iterator _endofstorage;
};
  • std::initializer_list使用场景

std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器（像map、vector、list）就增加std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值

class A
{
public:
	A(int a, double d, int b)
		:_a(a)
		, _d(d)
		, _b(b)
	{}
private:
	int _a;
	double _d;
	int _b;
};
class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	//内置类型的列表初始化
	vector<int> v1 = { 1, 2, 3, 4, 5 };
	vector<int> v2{ 1, 2, 3, 4, 5 };
	//vector (initializer_list<value_type> il,const allocator_type& alloc = allocator_type());


	auto lt1 = {1, 2, 3, 4};
	initializer_list<int> lt2 = { 1, 2, 3, 4 };
	//auto=initializer_list<int>


	map<string, int> dict1 = { pair<string, int>("sort", 1), pair<string, int>("insert", 2) };
	map<string, int> dict2 = { { "sort", 1 }, { "insert", 2 } };
	//首先{ "sort", 1 }, { "insert", 2 }创建成initializer_list<map<string,int>>类型的对象
	//最后map (initializer_list<value_type> il,const key_compare& comp = key_compare(),const allocator_type& alloc = allocator_type());
	//这个构造函数初始化dict2


	//自定义类型的列表初始化
	Date d1(2022, 3, 13);
	Date d2 = { 2022, 3, 15 };
	Date d3{ 2022, 3, 15 };
	Date{ 2022, 3, 15 };


	
	A aa1 = { 1, 1.11, 1};
	list<A> lt = { { 1, 1.11, 1}, { 2, 2.22, 1} };
	//首先{ { 1, 1.11, 1}, { 2, 2.22, 1} }创建成initializer_list<list<A>>类型的对象（首先是A类得有相应的构造函数才行）
	//最后list的构造函数初始化it
	return 0;
}

♠️ 3. 声明

c++11提供了多种简化声明的方式，尤其是在使用模板时。

♥️ 3.1 auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

int main()
{
	int i = 10;
	auto p = &i;
	
	auto pf = strcpy;
	//输出p、pf的类型
	cout << typeid(p).name() << endl;
	cout << typeid(pf).name() << endl;
	
	map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
	//map<string, string>::iterator it = dict.begin();
	
	auto it = dict.begin();
	
	return 0;
}

♥️ 3.2 decltype

关键字decltype将变量的类型声明为表达式指定的类型

// decltype的一些使用使用场景
template<class T1, class T2>
void F(T1 t1, T2 t2)
{
	decltype(t1 * t2) ret = t1 * t2;
	vector<decltype(t1* t2)> v;
	v.push_back(ret);
	cout << typeid(ret).name() << endl;
}

int main()
{
	int i = 10;
	auto p = &i;
	auto pf = strcpy;
	decltype(pf) pf1;    //char * (__cdecl*)(char *,char const *)
	vector<decltype(pf)> v;

	cout << typeid(p).name() << endl;
	cout << typeid(pf).name() << endl;

	return 0;
}

注意：decltype与auto的差别：auto必须要求显式初始化，而decltype没要求

♥️ 3.3 nullptr

由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

♠️ 4. STL中一些变化

新容器

用橘色圈起来是C++11中的一些几个新容器，但是实际最有用的是unordered_map和
unordered_set。其他的大家了解一下即可。

在这里插入图片描述

容器中的一些新方法

如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法，但是其实很多都是用得比较少的。
比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是可以返回const迭代器的，这些都是属于锦上添花的操作。

♠️ 5. final 和 override

final

  • final修饰类的时候，表示该类不能被继承
class A final //表示该类是最后一个类
{
private:
	int _year;
};
class B : public A //无法继承
{

};
  • final修饰虚函数时，这个虚函数不能被重写
class A 
{
public:
	virtual void fun() final//修饰虚函数
	{
		cout << "this is A" << endl;
	}
private:
	int _year;
};
class B : public A
{
public:
	virtual void fun()//父类虚函数用final修饰，表示最后一个虚函数，无法重写
	{
		cout << "this is B" << endl;
	}
};

override

  • 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错
class A 
{
public:
	virtual void fun()
	{
		cout << "this is A" << endl;
	}
private:
	int _year;
};
class B : public A
{
public:
	virtual void fun() override
	{
		cout << "this is B" << endl;
	}
};

♠️ 6. 右值引用和移动语义

♥️ 6.1 左值引用和右值引用

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，无论左值引用还是右值引用，都是给对象取别名。

  • 左值引用

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

int main()
{
	// 以下的p、b、c、*p都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;


	//	可以取地址
	cout << &p << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &(*p) << endl;
	
	b = c;
	
	// 以下几个是对上面左值的左值引用
	int*& rp = p;
	int& rb = b;
	const int& rc = c;
	int& pvalue = *p;
	return 0;
}
  • 右值引用

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。

int main()
{
	double x = 1.1, y = 2.2;
	// 以下几个都是常见的右值
	10; 
	x + y;
	fmin(x, y);
	// 以下几个都是对右值的右值引用
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);
	
	//	// 不能取地址
	//	cout << &10 << endl;
	//	cout << &(x+y) << endl;
	//	cout << &fmin(x, y) << endl;
	
	// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
	//10 = 1; 
	//x + y = 1;
	//fmin(x, y) = 1;
	return 0;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用

int main()
{
	double x = 1.1, y = 2.2;
	int&& rr1 = 10;
	const double&& rr2 = x + y;
	rr1 = 20;
	int& rr = rr1;
	//rr2 = 5.5;  // 报错
	return 0;
}

注意：左值引用可以连续左值引用，而右值引用是不可以连续右值引用的（右值引用后该变量为左值，不能使用右值引用了）

♥️ 6.2 左值引用和右值引用比较

左值引用总结：

  1. 左值引用只能引用左值，不能引用右值。
  2. 但是const左值引用既可引用左值，也可引用右值
int main()
{
	// 左值引用只能引用左值，不能引用右值。
	int a = 10;
	int& ra1 = a;// ra为a的别名
	//int& ra2 = 10;// 编译失败，因为10是右值
	// const左值引用既可引用左值，也可引用右值。
	const int& ra3 = 10;
	const int& ra4 = a;
	return 0;
}

右值引用总结：

  1. 右值引用只能右值，不能引用左值。
  2. 但是右值引用可以move以后的左值。
int main()
{
	// 右值引用只能右值，不能引用左值
	int&& r1 = 10;

	// error C2440: “初始化”: 无法从“int”转换为“int &&”
	// message : 无法将左值绑定到右值引用
	int a = 10;
	//int&& r2 = a;  //报错 右值引用只能右值，不能引用左值
	// 右值引用可以引用move以后的左值
	int&& r3 = move(a);
	return 0;
}

♥️ 6.3 右值引用使用场景和意义

右值引用可以补齐左值引用的短板

namespace lc
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			//cout << "string(char* str)" << endl;

			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		// s1.swap(s2)
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}

		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;

			string tmp(s._str);
			swap(tmp);
		}

		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 移动拷贝" << endl;

			//this->swap(s);
			swap(s);
		}

		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);

			return *this;
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;

				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}

♥️ 6.4 左值引用使用场景

void func1(bit::string s)
{}

void func2(const bit::string& s)
{}

int main()
{
	bit::string s1("hello world");
	// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
	func1(s1);
	func2(s1);
	
	// string operator+=(char ch) 传值返回存在深拷贝
	// string& operator+=(char ch) 传左值引用没有拷贝提高了效率
	s1 += '!';
	
	return 0;
}

♥️ 6.4 左值引用短板

但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：bit::string to_string(int value)函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

♥️ 6.5 右值引用和移动语义解决上述问题

移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人（将亡值）的资源来构造自己。

在这里插入图片描述
注意：出了作用域，如果返回对象不在了，不能使用引用返回(左值引用和右值引用都不可以)

namespace byih
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			//cout << "string(char* str)" << endl;

			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		// s1.swap(s2)
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}

		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;

			string tmp(s._str);
			swap(tmp);
		}

		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 移动拷贝" << endl;
			//this->swap(s);
			swap(s);
		}

		// 拷贝赋值
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);

			return *this;
		}

		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);

			return *this;
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;

				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}

		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};



	string to_string(int val)
	{
		string str;
		while (val)
		{
			int i = val % 10;
			str += ('0' + i);
			val /= 10;
		}
		reverse(str.begin(), str.end());
		return str;
	}
}

在这里插入图片描述

在这里插入图片描述

右值是将亡值而将亡值不一定是右值

注意：

按照语法，右值引用只能引用右值，但右值引用也能引用左值。因为：有些场景下，可能 真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move 函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性， 它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
使用move函数时，要注意该对象的资源（所开空间），该对象的资源会根据移动赋值、移动拷贝来决定，建议使用完move函数之后不要再使用该对象了

♥️ 6.6 STL容器插入接口函数也增加了右值引用版本

void push_back (value_type&& val);
int main()
{
	list<bit::string> lt;
	bit::string s1("1111");
	// 这里调用的是拷贝构造
	lt.push_back(s1);
	// 下面调用都是移动构造
	lt.push_back("2222");
	lt.push_back(std::move(s1));
	return 0;
}

运行结果：
// string(const string& s) -- 深拷贝
// string(string&& s) -- 移动语义
// string(string&& s) -- 移动语义

在这里插入图片描述

相关文章：

  • C/C++KTV点歌系统
  • 【Linux修炼手册：基本指令（完结）】
  • vmware ESXI 7 升级ESXI 8
  • 毕业设计 单片机温湿度环境检测仪 - stm32 物联网 嵌入式
  • 为什么在SPI通信中提供不同的模式？
  • 马上跨年了，如何用代码写一个“跨年倒计时”呢？
  • Arcgis中创建Python脚本工具
  • 内存读写指令 —— LDR / STR
  • 华为网工入门之eNSP小实验（5）--VLAN间相互通信的三种方法
  • 2022年底，我手里一共负责了30套系统
  • 绩效考核管理方案
  • C#修改富文本框（RichTextBox）指定内容颜色
  • Spark-内核(集群管理器、通讯架构、任务调度机制、Shuffle、内存管理)
  • RK3588平台开发系列讲解（GPIO篇）配置GPIO需要了解的概念
  • 在Python网络爬虫程序中使用生产者消费者模式爬取数据
  • [Vue CLI 3] 配置解析之 css.extract
  • C++类的相互关联
  • ES6系统学习----从Apollo Client看解构赋值
  • Kibana配置logstash，报表一体化
  • LeetCode算法系列_0891_子序列宽度之和
  • php的插入排序，通过双层for循环
  • Vue2.x学习三：事件处理生命周期钩子
  • 海量大数据大屏分析展示一步到位：DataWorks数据服务+MaxCompute Lightning对接DataV最佳实践...
  • 时间复杂度与空间复杂度分析
  • 微信小程序：实现悬浮返回和分享按钮
  • 用jquery写贪吃蛇
  • 找一份好的前端工作，起点很重要
  • ​​​​​​​GitLab 之 GitLab-Runner 安装，配置与问题汇总
  • ​Linux Ubuntu环境下使用docker构建spark运行环境（超级详细）
  • #pragma data_seg 共享数据区（转）
  • （3）nginx 配置(nginx.conf)
  • （7）STL算法之交换赋值
  • (ctrl.obj) : error LNK2038: 检测到“RuntimeLibrary”的不匹配项: 值“MDd_DynamicDebug”不匹配值“
  • （Java岗）秋招打卡！一本学历拿下美团、阿里、快手、米哈游offer
  • （附源码）springboot 校园学生兼职系统 毕业设计 742122
  • （含react-draggable库以及相关BUG如何解决）固定在左上方某盒子内（如按钮）添加可拖动功能，使用react hook语法实现
  • （已解决）什么是vue导航守卫
  • (转)EXC_BREAKPOINT僵尸错误
  • （转）编辑寄语：因为爱心，所以美丽
  • （转）原始图像数据和PDF中的图像数据
  • (轉貼) UML中文FAQ (OO) (UML)
  • .Net Core/.Net6/.Net8 ，启动配置/Program.cs 配置
  • .NET 命令行参数包含应用程序路径吗？
  • .Net 转战 Android 4.4 日常笔记（4）--按钮事件和国际化
  • .secret勒索病毒数据恢复|金蝶、用友、管家婆、OA、速达、ERP等软件数据库恢复
  • @Bean有哪些属性
  • @configuration注解_2w字长文给你讲透了配置类为什么要添加 @Configuration注解
  • @RestController注解的使用
  • [ vulhub漏洞复现篇 ] Apache APISIX 默认密钥漏洞 CVE-2020-13945
  • [383] 赎金信 js
  • [BUUCTF]-PWN:wustctf2020_number_game解析（补码，整数漏洞）
  • [C#]扩展方法
  • [CF]Codeforces Round #551 (Div. 2)
  • [Cocoa]iOS 开发者账户，联机调试，发布应用事宜
  • [ComfyUI进阶教程] animatediff视频提示词书写要点