精华内容
下载资源
问答
  • Variant

    2016-09-18 22:11:46
    Variant库包含一个不同于union的泛型类,用于在存储和操作来自于不同类型的对象。这个库的一个特点是支持类型安全的访问,减少了不同数据类型的类型转换代码的共同问题。 Variant 库如何改进你的程序? 对...
    Variant库包含一个不同于union的泛型类,用于在存储和操作来自于不同类型的对象。这个库的一个特点是支持类型安全的访问,减少了不同数据类型的类型转换代码的共同问题。

    Variant 库如何改进你的程序?
    • 对用户指定的多种类型的进行类型安全的存储和取回
    • 在标准库容器中存储不同类型的方法
    • 变量访问的编译期检查
    • 高效的、基于栈的变量存储


    Variant 库关注的是对一组限定类型的类型安全存储及取回,即非无类的联合。Boost.Variant 库与 Boost.Any 有许多共同之外,但在功能上也有不同的考虑。在每天的编程中通常都会需要用到非无类的联合(不同的类型)。保持类型安全的一个典型方法是使用抽象基类,但这不总是可以做到的;即使可以做得,堆分配和虚拟函数的代价也可能太高。你也可以尝试用不安全的无类类型,如 void* (它会导致不幸),或者是类型安全得无限制的可变类型,如 Boost.Any. 这里我们将看到 Boost.Variant,它支持限定的可变类型,即元素来自于一组支持的类型。

    许多其它的编程语言支持可变类型,它们也再次被证实是值得的。在C++内建的对可变类型的支持非常有限,只有某种形式的联合(union),而且主要是为了与C兼容而保留。Boost.Variant 通过一个类型模板 variant 补救了这种情形,并附随有安全的存储及取回值的工具。一个可变数据类型提供一个与当前值的类型无关的接口。如果你曾经用过别的可变类型,可能是仅能支持固定的一组类型。这个库不是这样的;你在使用 variant 时自己定义一组允许使用的类型,而一个程序中可以包含任意个不同的 variant 实例。为了取回保存在 variant 中的值,你要么知道当前值的真实类型,要么使用已提供的类型安全的访问者(visitor)机制。访问者机制使得 Variant 非常不同于其它可变类型的库,包括 Boost.Any (它可以持有任意类型的值),从而为处理这些类型提供了一个安全而健壮的环境。C++ 的联合只对内建类型以及 POD 类型有用,但这个库提供的非无类联合可以支持所有类型。最后,效率方面也被考虑到了,这个库基于栈存储来保存它的值,从而避免了昂贵的堆分配。

    Variant 如何适用于标准库?

    Boost.Variant 允许在标准库容器中存储不同的类型。由于在C++或C++标准库中都没有对可变类型的真正支持,这使得 Variant 成为了标准库的一个杰出且有用的扩充。

    Variant

    头文件: "boost/variant.hpp"


    Boost.Variant 用法

    在你的程序中使用 variant,要包含头文件 "boost/variant.hpp"。这个头文件包含了整个库,所以你不必知道要使用哪些单独的特性;以后,如果你要降低相关性,可以只包含那些解决问题所要的头文件。声明一个 variant 类型时,我们必须定义一组它可以存储的类型。最常用的办法是使用模板参数。一个可以持有类型为 int, std::string, 或 double 的值的 variant 声明如下。

    1. boost::variant<int,std::string,double> my_first_variant;  
    当变量 my_first_variant 被创建时,它含有一个缺省构造的 int, 因为 int 是这个 variant 可以持有的类型中的第一种类型。我们也可以传递一个可以转换为可用类型之一的值来初始化 variant.
    1. boost::variant<int,std::string,double>  
    2. my_first_variant("Hello world");  
    我们可以随时赋给新的值,只要这个新值有确定的类型并且可以转换为 variant 可以持有的类型中的某一种,它可以很好地工作。
    1. my_first_variant=24;  
    2. my_first_variant=2.52;  
    3. my_first_variant="Fabulous!";  
    4. my_first_variant=0;  
    在第一个赋值后,所含值的类型为 int; 第二个赋值后,类型为 double; 第三个后,类型为 std::string; 最后,又变回 int. 如果我们想看看,我们可以用函数 boost::get 取出这个值,如下:
    1. assert(boost::get<int>(my_first_variant)==0);  
    注意,如果调用 get 失败(当 my_first_variant 所含值不是类型 int 时就会发生),会抛出一个类型为 boost::bad_get 的异常。为了避免在失败时得到一个异常,我们可以传给 get 一个 variant 指针,这样 get 将返回一个指向它所含值的指针,或者如果给定类型与 variant 的值的类型不符则返回空指针。以下是它的用法:
    1. int* val=boost::get<int>(&my_first_variant);  
    2. assert(val && (*val)==0);  
    函数 get 是访问所含值的一种直接方法,事实上它与 boost::any 的 any_cast 很相似。注意,类型必须完全符合,包括相同的 cv-限定符(const 和 volatile)。但是,可以使用限制更多的 cv-限定符。如果类型不匹配且传给 get 的是一个 variant 指针,将返回空指针。否则,抛出一个类型为 bad_get 的异常。
    1. const int& i=boost::get<const int>(my_first_variant);  
    过分依赖于 get 的代码很容易变得脆弱;如果我们不知道所含值的类型,我们可能会想测试所有可能的组合,就如下面这个例子的做法。
    1. #include <iostream>  
    2. #include <string>  
    3. #include "boost/variant.hpp"  
    4. template <typename V> void print(V& v) {  
    5.   if (int* pi=boost::get<int>(&v))  
    6.     std::cout << "It's an int: " << *pi << '\n';  
    7.   else if (std::string* ps=boost::get<std::string>(&v))  
    8.     std::cout << "It's a std::string: " << *ps << '\n';  
    9.   else if (double* pd=boost::get<double>(&v))  
    10.     std::cout << "It's a double: " << *pd << '\n';  
    11.   std::cout << "My work here is done!\n";  
    12. }  
    13. int main() {  
    14.   boost::variant<int,std::string,double>  
    15.     my_first_variant("Hello there!");  
    16.   print(my_first_variant);  
    17.   my_first_variant=12;  
    18.   print(my_first_variant);  
    19.   my_first_variant=1.1;  
    20.   print(my_first_variant);  
    21. }  
    函数 print 现在可以正确工作,但如果我们决定改变 variant 的类型组的话会怎样?我们将引入一个微妙的bug,而不能在编译期捉住它;函数 print 不能打印任何其它我们没有预先想到的类型的值。如果我们没有使用模板函数,而是要求一个明确的 variant 类型,我们就要为不同类型的 variant 重载多个相同功能的函数。下一节将讨论访问 variant 的概念,以及这种(类型安全的)访问机制解决的问题。

    访问Variants

    让我们从一个例子开始,它解释了为什么使用 get 并没有你想要的那么可靠。从前面父子的代码开始,我们来修改一下 variant 可以包含的类型,并对 variant 的一个 char 值来调用print。
    1. int main() {  
    2.   boost::variant<int,std::string,double,char>  
    3.     my_first_variant("Hello there!");  
    4.   print(my_first_variant);  
    5.   my_first_variant=12;  
    6.   print(my_first_variant);  
    7.   my_first_variant=1.1;  
    8.   print(my_first_variant);  
    9.   my_first_variant='a';  
    10.   print(my_first_variant);  
    11. }  
    虽然我们给 variant 的类型组增加了 char ,并且程序的最后两行设置了一个 char 值并调用 print ,编译器也不会有意见 (注意,print 是以 variant 的类型来特化的,所以它可以很容易适应新的 variant 定义)。以下是这个程序的运行结果:
    1. It's a std::string: Hello there!  
    2. My work here is done!  
    3. It's an int: 12  
    4. My work here is done!  
    5. It's a double: 1.1  
    6. My work here is done!  
    7. My work here is done!  
    这个输出显示了一个问题。最后一个"My work here is done!"之前没有值的报告。原因是很简单,print 不能输出除了它原来设计好的那些类型(std::string, int, 和 double)以外的任何值,但它可以干净地编译和运行。如果 variant 的当前类型不被 print 支持,它的值就会被简单地忽略掉。使用 get 还有更多潜在的问题,例如 if 语句的顺序要与类的层次相一致。注意,这并不是说你应该完全避免使用 get;它只是说有些时候它不是最好的方法。有一种更好的机制,可以允许我们规定哪些类型的值可以接受,并且这些规定是在编译期生效的。这是就 variant 访问机制的作用。通过把一个访问器应用到 variant,编译器可以保证它们完全兼容。Boost.Variant 中这些访问器是带有一些函数调用操作符的函数对象,这些函数调用操作符接受与它们所访问的 variant 可以包含的类型组相对应的参数。
    现在我们用访问器来重写那个声名狼籍的函数 print ,如下:
    1. class print_visitor : public boost::static_visitor<void> {  
    2. public:  
    3.   void operator()(int i) const {  
    4.     std::cout << "It's an int: " << i << '\n';  
    5.   }  
    6.   void operator()(std::string s) const {  
    7.     std::cout << "It's a std::string: " << s << '\n';  
    8.   }  
    9.   void operator()(double d) const {  
    10.     std::cout << "It's a double: " << d << '\n';  
    11.   }  
    12. };  
    要让 print_visitor 成为 variant 的一个访问器,我们要让它派生自 boost::static_visitor 以获得正确的 typedef (result_type), 并明确地声明这个类是一个访问器类型。这个类实现了三个重载版本的函数调用操作符,分别接受一个 int, 一个 std::string, 和一个 double 。为了访问 variant, 你要用函数 boost::apply_visitor(visitor, variant). 如果我们用对 apply_visitor的调用来替换前面的 print 调用,我们可以得到如下代码:
    1. int main() {  
    2.   boost::variant<int,std::string,double,char>  
    3.     my_first_variant("Hello there!");  
    4.   print_visitor v;  
    5.   boost::apply_visitor(v,my_first_variant);  
    6.   my_first_variant=12;  
    7.   boost::apply_visitor(v,my_first_variant);  
    8.   my_first_variant=1.1;  
    9.   boost::apply_visitor(v,my_first_variant);  
    10.   my_first_variant='a';  
    11.   boost::apply_visitor(v,my_first_variant);  
    12. }  
    这里,我们创建了一个 print_visitor, 名为 v, 并把它应用于赋值后的 my_first_ variant 。因为我们没有一个函数调用操作符接受 char, 这段代码会编译失败,是吗?错!一个 char 可以转换为一个 int, 所以这个访问器可以兼容我们的 variant 类型。以下是程序运行的结果。
    1. It's a std::string: Hello there!  
    2. It's an int: 12  
    3. It's a double: 1.1  
    4. It's an int: 97  
    这里我们可以学到两件事情:第一个是字母 a 的 ASCII 码值为 97, 更重要的是第二个,如果一个访问器以传值的方式传递参数,则传送的值可以应用隐式转换。如果我们想访问器只能使用精确的类型(同时也避免拷贝从 variant 得到的值),我们必须修改访问器的调用操作符传递参数的方式。以下这个版本的 print_visitor 只能使用类型 int, std::string, 和 double; 以及可以隐式转换到这些类型的引用的其它类型
    1. class print_visitor : public boost::static_visitor<void> {  
    2. public:  
    3.   void operator()(int& i) const {  
    4.     std::cout << "It's an int: " << i << '\n';  
    5.   }  
    6.   void operator()(std::string& s) const {  
    7.     std::cout << "It's a std::string: " << s << '\n';  
    8.   }  
    9.   void operator()(double& d) const {  
    10.     std::cout << "It's a double: " << d << '\n';  
    11.   }  
    12. };  
    如果再编译一下这个程序,编译器就不高兴了,它会输出如下信息:
    1. c:/boost_cvs/boost/boost/variant/variant.hpp:  
    2. In member function `typename Visitor::result_type boost::detail:: variant::  
    3. invoke_visitor<Visitor>::internal_visit(T&, int)  
    4. [with T = char, Visitor = print_visitor]':  
    5. [Snipped lines of irrelevant information here]  
    6. c:/boost_cvs/boost/boost/variant/variant.hpp:807:  
    7. error: no match for call to `(print_visitor) (char&)'  
    8. variant_sample1.cpp:40: error: candidates are:  
    9. void print_visitor::operator()(int&) const  
    10. variant_sample1.cpp:44: error:  
    11. void print_visitor::operator()(std::string&) const  
    12. variant_sample1.cpp:48: error:  
    13. void print_visitor::operator()(double&) const  
    这个错误指出了问题:没有一个候选的函数接受 char 参数!为什么说类型安全的编译期访问机制是一个强大的机制,这正是一个重要的原因。它使得访问机制强烈依赖于类型,避免了讨厌的类型变换。创建访问器与创建其它函数对象一样容易,因此学习曲线并不陡峭。当 variant 中的类型组可能会改变时(它们总是倾向于变化!),创建访问器要比单单依赖 get 更可靠。虽然开始需要更高的代价,但绝对是值得的。

    泛型访问器

    通过使用访问器机制和泛型的调用操作符,可以创建能够接受任意类型的泛型访问器(无论是在语法上还是语义上,都可以实现泛型调用操作符)。这对于统一地处理不同的类型非常有用。C++的操作符就是"通用"性的一个典型例子,如算术和IO流的位移操作符。以下例子使用 operator<< 来输出 variant 的值到一个流。
    1. #include <iostream>  
    2. #include <sstream>  
    3. #include <string>  
    4. #include <sstream>  
    5. #include "boost/variant.hpp"  
    6. class stream_output_visitor :  
    7.   public boost::static_visitor<void> {  
    8.   std::ostream& os_;  
    9. public:  
    10.   stream_output_visitor(std::ostream& os) : os_(os) {}  
    11.   template <typename T> void operator()(T& t) const {  
    12.     os_ << t << '\n';  
    13.   }  
    14. };  
    15. int main() {  
    16.   boost::variant<int,std::string> var;  
    17.   var=100;  
    18.   boost::apply_visitor(stream_output_visitor(std::cout),var);  
    19.   var="One hundred";  
    20.   boost::apply_visitor(stream_output_visitor(std::cout),var);  
    21. }  
    主要思想是 stream_output_visitor 中的调用操作符是一个成员函数模板,它在访问每一种类型(本例中是 int 和 std::string)时分别实例化。因为 std::cout << 100 和 std::cout << std::string("One hundred") 都已经有定义了,所以这段代码可以编译并工作良好。

    当然,操作符仅是可以使用泛型访问器的一个例子;它们常常应用于更多的类型。在某些值上调用函数,或者将它们作为参数传给其它的函数时,要求就是对于所有传给操作符的类型都要有相应的成员函数存在,并且对于被调用的函数要有合适的重载。这种泛型调用操作符的另一个有趣的方面是,可以对某些类型特化其行为,但对于其余类型则仍允许泛型的实现。在某种意义上,这涉及到模板特化,即基于类型信息的行为特殊化。

    二元访问器

    我们前面看到的访问器都是一元的,即它们只接受一个 variant 作为唯一的参数。二元访问器接受两个(可能是不同的) variant. 这种概念对于实现两个 variant 间的关系很有用。作为例子,我们为 variant 类型将创建一个按字典顺序的排序。为此,我们使用一个来自于标准库的非常有用的组件:std::ostringstream. 它接受任意可流输出的东西,并且在需要时产生一个独立的 std::string 。我们从而可以按字典序比较完全不同的 variant 类型,只要假设所有限定的类型都支持流输出。和普通的访问器一样,二元访问器也派生自 boost::static_visitor, 并且用模板参数表示调用操作符的返回类型。因为我们是创建一个谓词,因此返回类型为 bool. 以下是一个我们即将用到的二元谓词。
    1. class lexicographical_visitor :  
    2.   public boost::static_visitor<bool> {  
    3. public:  
    4.   template <typename LHS,typename RHS>  
    5.   bool operator()(const LHS& lhs,const RHS& rhs) const {  
    6.     return get_string(lhs)<get_string(rhs);  
    7.   }  
    8. private:  
    9.   template <typename T> static std::string  
    10.   get_string(const T& t) {  
    11.     std::ostringstream s;  
    12.     s << t;  
    13.     return s.str();  
    14.   }  
    15.   static const std::string& get_string(const std::string& s) {  
    16.     return s;  
    17.   }  
    18. };  
    这里的调用操作符泛化了它的两个参数,这意味着它接受任意两种类型的组合。对于 variant 的可用类型组的要求就是它们必须是可流输出(OutputStreamable)的。成员函数模板 get_string 使用一个 std::ostringstream 来把它的参数转换为字符串表示,所以要求参数必须是可流输出的(为了使用 std::ostringstream, 记得要包含头文件 <sstream>)。成员函数 get_string 针对类型为 std::string 的参数进行特化,由于类型已经符合要求,所以它跳过了 std::ostringstream 而直接返回它的参数。在两个参数都转为 std::string 以后,剩下的就是使用 operator< 来比较它们了。现在我们把这个访问器放入测试代码,来对一个容器中的元素进行排序(我们还将重用我们在本章前面创建的 stream_output_visitor )。
    1. #include <iostream>  
    2. #include <string>  
    3. #include <vector>  
    4. #include <algorithm>  
    5. #include "boost/variant.hpp"  
    6. int main() {  
    7.   boost::variant<int,std::string> var1="100";  
    8.   boost::variant<double> var2=99.99;  
    9.   std::cout << "var1<var2: " <<  
    10.     boost::apply_visitor(  
    11.       lexicographical_visitor(),var1,var2) << '\n';  
    12.   typedef std::vector<  
    13.     boost::variant<int,std::string,double> > vec_type;  
    14.   vec_type vec;  
    15.   vec.push_back("Hello");  
    16.   vec.push_back(12);  
    17.   vec.push_back(1.12);  
    18.   vec.push_back("0");  
    19.   stream_output_visitor sv(std::cout);  
    20.   std::for_each(vec.begin(),vec.end(),sv);  
    21.   lexicographical_visitor lv;  
    22.   std::sort(vec.begin(),vec.end(),boost::apply_visitor(lv));  
    23.   std::cout << '\n';  
    24.   std::for_each(vec.begin(),vec.end(),sv);  
    25. };  
    当 sort 算法被执行时,它使用我们传入的谓词来比较它的元素,它是一个 lexicographical_visitor 实例。注意,boost::variant 已经定义了 operator<, 所以不使用谓词也可以对容器进行排序。
    1. std::sort(vec.begin(),vec.end());  
    但是这种缺省的排序是首先使用 which 来检查当前值的索引,所以元素的排列顺序将是 12, 0, Hello, 1.12, 而我们想要的是按字典序来排序。因为 variant 类已经提供了 operator< 和 operator== ,所以 variant 可以用作所有标准库容器的元素类型。当缺省的关系比较不够用时,你需要用二元访问器来实现一个。

    更多应该知道的事情

    我们并没有涉及到 Boost.Variant 库的所有功能。其它更为先进的特性不如我们已经提到的那么常用。但是,我会简要地说一下,因此你将至少知道在需要时可以找到哪些可用的东西。宏 BOOST_VARIANT_ENUM_PARAMS, 可用于为 variant 类型重载/特化函数和类模板。这个宏用于列举 variant 可以包含的类型组。还有支持使用类型序列来创建 variant 类型,即通过 make_variant_over 编译期列表来表示 variant 的类型组。还有递归的 variant 类型,可用于创建它们自己类型的表达式,递归 variant 类型使用 recursive_wrapper, make_recursive_variant, 和 make_recursive_variant_over. 如果你需要这些额外的特性,在线文档可以很好地解释它们。
    Variant 总结

    类别联合(discriminated unions)在日常编程中非常有用,这个事实无须惊讶,Boost.Variant 库提供了高效且易用的 variant 类型,它正是基于类别联合的。因为C++的联合对于很多类型很难使用(它只支持内建类型和 POD 类型),长期以来一直需要别的东西来取代它。许多创建类别联合的尝试都存在某些重要的缺点。例如,早期的尝试通常仅支持固定的一组类型,的确妨碍了维护性和灵活性。Boost.Variant 通过模板避免了这些限制,理论上允许创建任意的 variant 类型。在处理类别联合时类型转换代码总会成为问题所在;在处理前需要测试当前值的类型,这导致了维护的麻烦。Boost.Variant 提供了简单的值取回操作以及类型安全的访问机制,这是解决问题的新颖方法。最后,效率也是早期的尝试所关心的,这个库也很好地照顾到了效率,它使用基于栈的存储,而不是基于堆的。

    Boost.Variant 是一个成熟的库,有非常多的特性,使用 variant 类型容易且高效。这是 Boost.Any 库的补充,同样应该成为你的专业C++工具箱中的一员。

    Boost.Variant 的作者是 Eric Friedman 和 Itay Maman.
    展开全文
  • VARIANT

    2014-05-29 14:28:00
    VARIANT辅助函数 VariantChangeType VariantInit VariantCopy VariantCopyInd VariantClear 1 if (varOp1.vt == VT_BSTR && varOp2.vt == VT_BSTR) 2 { 3 VariantInit(pvarResult); 4 .....

    VARIANT辅助函数

     

    VariantChangeType

    VariantInit

    VariantCopy

    VariantCopyInd

    VariantClear

     

     1 if (varOp1.vt == VT_BSTR && varOp2.vt == VT_BSTR)
     2 {
     3     VariantInit(pvarResult);
     4     ComBSTR bstr(varOp1.bstrVal);
     5     bstr.append(varOp2.bstrVal);
     6 
     7     pvarResult->vt = VT_BSTR;
     8     pvarResult->bstrVal = bstr.Copy();
     9     return S_OK;  
    10 }

     

     

    1. VARIANT数据类型不是简单的基本内置类型,比如:int char long等,这就意味着VARIANT是通过struct定义的,在C++中struct具备和class几乎同等的功能,也可以这么来讲,VARIANT也是一个类,在它的定义中有以下语句:

    typedef struct tagVARIANT VARIANT;

    而CComVARIANT的定义是:

    class CComVariant : public tagVARIANT

    这就意味着CComVariant类是VARIANT的子类,在参数传递的过程中,如果要求传入的是某个类的指针类型,那么这个类指针或者这个类的继承链中的任何一个子类的指针传入进去后都是合法的。那么,这就说所要要求传入VARIANT * 数据类型的地方都可以用CComVariant * 的类型来代替!

    据此,我们可以得出一个结论,在ATL中,CComVariant完全可以取代VARIANT,而且更加方便可靠!

    转载于:https://www.cnblogs.com/aoun/p/3759073.html

    展开全文
  • variant

    2012-06-03 14:11:00
    简要的说,variant是有限定的变体类型(any是不限定的)。限定有限定的好处,variant是基于栈来储存值的,比起any用堆来要快得多;另外variant与STL的配合也容易得多。 Boost.VariantVariant库包含一个不同...

    简要的说,variant是有限定的变体类型(any是不限定的)。限定有限定的好处,variant是基于栈来储存值的,比起any用堆来要快得多;另外variantSTL的配合也容易得多。

     

    Boost.Variant

    Variant库包含一个不同于union的泛型类,用于在存储和操作来自于不同类型的对象。这个库的一个特点是支持类型安全的访问,减少了不同数据类型的类型转换代码的共同问题。

    Variant 库如何改进你的程序?
    • 对用户指定的多种类型的进行类型安全的存储和取回
    • 在标准库容器中存储不同类型的方法
    • 变量访问的编译期检查
    • 高效的、基于栈的变量存储

     

    转载于:https://www.cnblogs.com/zhangzhang/archive/2012/06/03/2532710.html

    展开全文
  • Variant4g

    2019-10-28 14:25:26
    Variant4g
  • variant vs variant2

    2020-11-22 04:34:13
    <p>I run two workflow (variant vs variant2) with the same set of fastq files; with the same aligner and genotyper. the number of reads, near bait bases, and off target bases are all off (or lower than...
  • Variant groups

    2020-11-24 19:45:18
    <div><p>This is an amended version of the variant groups branch. I'm not sure if this is the best way to submit changes. <p>While testing it, I noticed a few issues which are fixed in this pull ...
  • Variant management

    2020-12-05 21:37:48
    <p>That aside, one thing that I find missing in many of the CAD tools is variant management. This more of a professional level feature but is something that I would really like to see in a set of free...
  • Variant initialize

    2020-11-29 21:47:35
    <p>I want to initialize a variant to a certain type's default value (return invalid variant if the type doesn't have default constructor). How do I do it? <p>something like: <code>rttr::...
  • 变体类型 Variant VARIANT

    2015-07-16 16:25:00
    变体类型 Variant VARIANT class RTL_DELPHIRETURN Variant: public TVarDatatypedef struct tagVARIANT VARIANT; Variant Arrays V: Variant; V:= VarArrayCreate([0,9], varInteger); CreateOleObject.....

    变体类型 Variant VARIANT

    class RTL_DELPHIRETURN Variant: public TVarData

    typedef struct    tagVARIANT  VARIANT;

    Variant Arrays

    V: Variant;
    
    V := VarArrayCreate([0,9], varInteger);
    
     CreateOleObject("ss.comds"); 
    OleFunction

    转载于:https://www.cnblogs.com/cb168/p/4651663.html

    展开全文
  • variant2

    2020-11-22 04:34:14
    <div><p>so, for the variant2 pipeline, trim read is not recommended? <p>and for some reasons, i have issues generating insert size, duplicates and variant summary, where should I trace after for ...
  • Variant upcasting

    2020-11-29 08:13:00
    m trying to cast a variant hold a <code>shared_ptr<Derived></code> of a derived class to a <code>shared_ptr<Base></code> of its base class (i.e. upcasting). I've searched previous ...
  • Recursive variant

    2020-12-08 22:46:47
    <div><ul><li>Made the variant type in the script interface recursive, so that functions can return structured data</li><li>Corresponding translation functions in python</li><li>some clean up of the ...
  • <div><p>allows user to pass through specific variant ID. </p><p>该提问来源于开源项目:Shopify/buy-button-js</p></div>
  • Windows Variant

    2020-12-26 09:44:30
    <div><p>was curious if there were plans for a Windows (7) variant?</p><p>该提问来源于开源项目:uipoet/sublime-jshint</p></div>
  • <p>However, passing Value back into a serializer is a problem because the serialize_*_variant methods require the variant name be a string with static lifetime, but the <code>Value::Typed(String, ...
  • Variant 数组

    2019-01-12 17:02:25
    Variant 数组 Variant: 一种可以拥有各种数据类型; 也可以告诉目前存储的数据是什么类型(通过使用VarType函数); 可以给相同的Variant分配不同的数据类型,只要Variant包含数字值就可以执行算法; variant...
  • boost variant

    2019-06-20 19:30:00
    Boost Variant resembles union. You can store values of different types in a boost::variant. 1. #include <boost/variant.hpp> #include <string> int main() { boost::variant<doub....
  • QVariant vs VARIANT

    千次阅读 多人点赞 2020-11-11 10:57:35
    QVariant 是一个变体数据类型类 ,封装了类似c++ VARIANT 这种结构体的数据类型! QVariant 这个类型充当着最常见的数据类型的联合。QVariant 可以保存很多Qt的数据类型,包括QBrush、QColor、QCursor、QDateTime、...
  • variant 用法

    2013-08-21 09:53:47
    variant 用法,包括函数,变量如何使用
  • VARIANT的结构可以参考头文件VC98\Include\OAIDL.H中关于结构体tagVARIANT的定义。对于VARIANT变量的赋值:首先给vt成员赋值,指明数据类型,再对联合结构中相同数据类型的变量赋值,举个例子:VARIANT va;int a=...
  • variant

    2019-10-25 22:28:56
    any库类型安全但没有限定的变体类型 variant库有类型安全也还有限定的变体 variant<int,string,double> a("hello"); //可以随时为a赋值,只要新值有确定的类型,并且可以隐式的转换为variant中的一种 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,657
精华内容 10,662
关键字:

variant