完全掌握C++编程中构造函数使用的超级学习教程

构造函数是一种可初始化其类的实例的成员函数。构造函数具有与类相同的名称,没有返回值。构造函数可以具有任意数量的参数,类可以具有任意数量的重载构造函数。构造函数可以具有任何可访问性(公共、受保护或私有)。如果未定义任何构造函数,则编译器会生成不采用任何参数的默认构造函数;可以通过将默认构造函数声明为已删除来重写此行为。
构造函数顺序
构造函数按此顺序执行工作:
按声明顺序调用基类和成员构造函数。
如果类派生自虚拟基类,则会将对象的虚拟基指针初始化。
如果类具有或继承了虚函数,则会将对象的虚函数指针初始化。虚函数指针指向类中的虚函数表,确保虚函数正确地调用绑定代码。
它执行自己函数体中的所有代码。
下面的示例显示,在派生类的构造函数中,基类和成员构造函数的调用顺序。首先,调用基构造函数,然后按照基类成员在类声明中出现的顺序对这些成员进行初始化,然后,调用派生构造函数。

#include <iostream>
using namespace std;

class Contained1 {
public:
  Contained1() {
    cout << "Contained1 constructor." << endl;
  }
};

class Contained2 {
public:
  Contained2() {
    cout << "Contained2 constructor." << endl;
  }
};

class Contained3 {
public:
  Contained3() {
    cout << "Contained3 constructor." << endl;
  }
};

class BaseContainer {
public:
  BaseContainer() {
    cout << "BaseContainer constructor." << endl;
  }
private:
  Contained1 c1;
  Contained2 c2;
};

class DerivedContainer : public BaseContainer {
public:
  DerivedContainer() : BaseContainer() {
    cout << "DerivedContainer constructor." << endl;
  }
private:
  Contained3 c3;
};

int main() {
  DerivedContainer dc;
  int x = 3;
}

这是输出:

Contained1 constructor.
Contained2 constructor.
BaseContainer constructor.
Contained3 constructor.
DerivedContainer constructor.

如果构造函数引发异常,析构的顺序与构造的顺序相反:
构造函数主体中的代码将展开。
基类和成员对象将被销毁,顺序与声明顺序相反。
如果是非委托构造函数,所有完全构造的基类对象和成员均将被销毁。但是,对象本身不是完全构造的,因此析构函数不会运行。
成员列表
使用成员初始值设定项列表从构造函数参数初始化类成员。此方法使用直接初始化,这比在构造函数体内使用赋值运算符更高效。

class Box {
public:
  Box(int width, int length, int height)
    : m_width(width), m_length(length), m_height(height) // member init list
  {}
  int Volume() {return m_width * m_length * m_height; }
private:
  int m_width;
  int m_length;
  int m_height;

};

创建 Box 对象:

Box b(42, 21, 12);
cout << "The volume is " << b.Volume();

显式构造函数
如果类具有带一个参数的构造函数,或是如果除了一个参数之外的所有参数都具有默认值,则参数类型可以隐式转换为类类型。例如,如果 Box 类具有一个类似于下面这样的构造函数:

Box(int size): m_width(size), m_length(size), m_height(size){}

可以初始化 Box,如下所示:

Box b = 42;

或将一个 int 传递给采用 Box 的函数:

class ShippingOrder
{
public:
  ShippingOrder(Box b, double postage) : m_box(b), m_postage(postage){}

private:
  Box m_box;
  double m_postage;
}
//elsewhere...
  ShippingOrder so(42, 10.8);

这类转换可能在某些情况下很有用,但更常见的是,它们可能会导致代码中发生细微但严重的错误。作为一般规则,应对构造函数使用 explicit 关键字(和用户定义的运算符)以防止出现这种隐式类型转换:

explicit Box(int size): m_width(size), m_length(size), m_height(size){}

构造函数是显式函数时,此行会导致编译器错误:ShippingOrder so(42, 10.8);。
默认构造函数
默认构造函数没有参数;它们遵循略有不同的规则:
默认构造函数是一个特殊成员函数;如果没有在类中声明构造函数,则编译器会提供默认构造函数:

class Box {
  Box(int width, int length, int height)
    : m_width(width), m_length(length), m_height(height){}
};

int main(){

  Box box1{}; // call compiler-generated default ctor
  Box box2;  // call compiler-generated default ctor
}

当你调用默认构造函数并尝试使用括号时,系统将发出警告:

class myclass{};
int main(){
myclass mc();   // warning C4930: prototyped function not called (was a variable definition intended?)
}

这是“最棘手的解析”问题的示例。这种示例表达式既可以解释为函数的声明,也可以解释为对默认构造函数的调用,而且 C++ 分析器更偏向于声明,因此表达式会被视为函数声明。
如果声明了任何非默认构造函数,编译器不会提供默认构造函数:

class Box {
  Box(int width, int length, int height)
    : m_width(width), m_length(length), m_height(height){}
};
private:
  int m_width;
  int m_length;
  int m_height;

};

int main(){

  Box box1(1, 2, 3);
  Box box2{ 2, 3, 4 };
  Box box4;   // compiler error C2512: no appropriate default constructor available
}

如果类没有默认构造函数,将无法通过单独使用方括号语法来构造该类的对象数组。例如,在前面提到的代码块中,框的数组无法进行如下声明:

Box boxes[3];  // compiler error C2512: no appropriate default constructor available

但是,你可以使用初始值设定项列表将框的数组初始化:

Box boxes[3]{ { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

复制和移动构造函数
复制构造函数是特殊成员函数,它采用对相同类型对象的引用作为输入,并创建它的副本。移动也是特殊成员函数构造函数,它将现有对象的所有权移交给新变量,而不复制原始数据。

显式默认构造函数和已删除构造函数
你可以显式设置默认复制构造函数、设置默认构造函数、移动构造函数、复制赋值运算符、移动赋值运算符和析构函数。你可以显式删除所有特殊成员函数。
派生类中的构造函数
派生类构造函数始终调用基类构造函数,因此,在完成任何额外任务之前,它可以依赖于完全构造的基类。调用基类构造函数进行派生,例如,如果 ClassA 派生自 ClassB,ClassB 派生自 ClassC,那么首先调用 ClassC 构造函数,然后调用 ClassB 构造函数,最后调用 ClassA 构造函数。
如果基类没有默认构造函数,则必须在派生类构造函数中提供基类构造函数参数:

class Box {
public:
  Box(int width, int length, int height){
    m_width = width;
    m_length = length;
    m_height = height;
  }

private:
  int m_width;
  int m_length;
  int m_height;
};

class StorageBox : public Box {
public:
  StorageBox(int width, int length, int height, const string label&) : Box(width, length, height){
    m_label = label;
  }
private:
  string m_label;
};

int main(){

  const string aLabel = "aLabel";
  StorageBox sb(1, 2, 3, aLabel);
}

具有多重继承的类的构造函数
如果类从多个基类派生,那么将按照派生类声明中列出的顺序调用基类构造函数:

#include <iostream>
using namespace std;

class BaseClass1 {
public:
  BaseClass1() {
    cout << "BaseClass1 constructor." << endl;
  }
};
class BaseClass2 {
public:
  BaseClass2() {
    cout << "BaseClass2 constructor." << endl;
  }
};
class BaseClass3{
public:
  BaseClass3() {
    cout << "BaseClass3 constructor." << endl;
  }
};
class DerivedClass : public BaseClass1, public BaseClass2, public BaseClass3 {
public:
  DerivedClass() {
    cout << "DerivedClass constructor." << endl;
  }
};

int main() {
  DerivedClass dc;
}

你应看到以下输出:

BaseClass1 constructor.
BaseClass2 constructor.
BaseClass3 constructor.
DerivedClass constructor.

构造函数中的虚函数
我们建议你谨慎调用构造函数中的虚函数。基类构造函数始终在派生类构造函数之前调用,因此基构造函数中调用的函数是基类版本,而非派生类版本。在下面的示例中,构造 DerivedClass 会导致执行 BaseClass 的 print_it() 实现早于 DerivedClass 构造函数导致执行 DerivedClass 的 print_it() 实现:

#include <iostream>
using namespace std;

class BaseClass{
public:
  BaseClass(){
    print_it();
  }
  virtual void print_it() {
    cout << "BaseClass print_it" << endl;
  }
};

class DerivedClass : public BaseClass {
public:
  DerivedClass() {
    print_it();
  }
  virtual void print_it(){
    cout << "Derived Class print_it" << endl;
  }
};

int main() {

  DerivedClass dc;
}

这是输出:

BaseClass print_it
Derived Class print_it

构造函数和复合类
包含类类型成员的类称为“复合类”。创建复合类的类类型成员时,调用类自己的构造函数之前,先调用构造函数。当包含的类没有默认构造函数是,必须使用复合类构造函数中的初始化列表。在之前的 StorageBox 示例中,如果将 m_label 成员变量的类型更改为新的 Label 类,则必须调用基类构造函数,并且将 m_label 变量(位于 StorageBox 构造函数中)初始化:

class Label {
public:
  Label(const string& name, const string& address) { m_name = name; m_address = address; }
  string m_name;
  string m_address;
};

class StorageBox : public Box {
public:
  StorageBox(int width, int length, int height, Label label)
    : Box(width, length, height), m_label(label){}
private:
  Label m_label;
};

int main(){
// passing a named Label
  Label label1{ "some_name", "some_address" };
  StorageBox sb1(1, 2, 3, label1);

  // passing a temporary label
  StorageBox sb2(3, 4, 5, Label{ "another name", "another address" });

  // passing a temporary label as an initializer list
  StorageBox sb3(1, 2, 3, {"myname", "myaddress"});
}

委托构造函数
委托构造函数调用同一类中的其他构造函数,完成部分初始化工作。在下面的示例中,派生类具有三个构造函数,第二个构造函数委托第一个,第三个构造函数委托第二个:

#include <iostream>
using namespace std;

class ConstructorDestructor {
public:
  ConstructorDestructor() {
    cout << "ConstructorDestructor default constructor." << endl;
  }
  ConstructorDestructor(int int1) {
    cout << "ConstructorDestructor constructor with 1 int." << endl;
  }
  ConstructorDestructor(int int1, int int2) : ConstructorDestructor(int1) {
    cout << "ConstructorDestructor constructor with 2 ints." << endl;

    throw exception();
  }
  ConstructorDestructor(int int1, int int2, int int3) : ConstructorDestructor(int1, int2) {
    cout << "ConstructorDestructor constructor with 3 ints." << endl;
  }
  ~ConstructorDestructor() {
    cout << "ConstructorDestructor destructor." << endl;
  }
};

int main() {
  ConstructorDestructor dc(1, 2, 3);
}

这是输出:

ConstructorDestructor constructor with 1 int.
ConstructorDestructor constructor with 2 ints.
ConstructorDestructor constructor with 3 ints.

所有构造函数完成后,完全初始化的构造函数将立即创建对象。 DerivedContainer(int int1) 成功,但是 DerivedContainer(int int1, int int2) 失败,并调用析构函数。

class ConstructorDestructor {
public:
  ConstructorDestructor() {
    cout << "ConstructorDestructor default constructor." << endl;
  }
  ConstructorDestructor(int int1) {
    cout << "ConstructorDestructor constructor with 1 int." << endl;
  }
  ConstructorDestructor(int int1, int int2) : ConstructorDestructor(int1) {
    cout << "ConstructorDestructor constructor with 2 ints." << endl;
    throw exception();
  }
  ConstructorDestructor(int int1, int int2, int int3) : ConstructorDestructor(int1, int2) {
    cout << "ConstructorDestructor constructor with 3 ints." << endl;
  }

  ~ConstructorDestructor() {
    cout << "ConstructorDestructor destructor." << endl;
  }
};

int main() {

  try {
    ConstructorDestructor cd{ 1, 2, 3 };
  }
  catch (const exception& ex){
  }
}

输出:

ConstructorDestructor constructor with 1 int.
ConstructorDestructor constructor with 2 ints.
ConstructorDestructor destructor.

继承构造函数 (C++11)
派生类可以使用 using 声明从直接基类继承构造函数,如下面的示例所示:

#include <iostream>
using namespace std;

class Base
{
public:
  Base() { cout << "Base()" << endl; }
  Base(const Base& other) { cout << "Base(Base&)" << endl; }
  explicit Base(int i) : num(i) { cout << "Base(int)" << endl; }
  explicit Base(char c) : letter(c) { cout << "Base(char)" << endl; }

private:
  int num;
  char letter;
};

class Derived : Base
{
public:
  // Inherit all constructors from Base
  using Base::Base;

private:
  // Can't initialize newMember from Base constructors.
  int newMember{ 0 };
};

int main(int argc, char argv[])
{
  cout << "Derived d1(5) calls: ";
  Derived d1(5);
  cout << "Derived d1('c') calls: ";
  Derived d2('c');
  cout << "Derived d3 = d2 calls: " ;
  Derived d3 = d2;
  cout << "Derived d4 calls: ";
  Derived d4; 

  // Keep console open in debug mode:
  cout << endl << "Press Enter to exit.";
  char in[1];
  cin.getline(in, 1);
  return 0;
}

输出:

Derived d1(5) calls: Base(int)
Derived d1('c') calls: Base(char)
Derived d3 = d2 calls: Base(Base&)
Derived d4 calls: Base()
Press Enter to exit.

using 语句可将来自基类的所有构造函数引入范围(除了签名与派生类中的构造函数相同的构造函数)。一般而言,当派生类未声明新数据成员或构造函数时,最好使用继承构造函数。
如果类型指定基类,则类模板可以从类型参数继承所有构造函数:

template< typename T >
class Derived : T {
  using T::T;  // declare the constructors from T
  // ...
};

如果基类的构造函数具有相同签名,则派生类无法从多个基类继承。
声明构造函数的规则
构造函数与它的类的名称相同。可以声明任意数量的构造函数,这取决于重载函数的规则。

argument-declaration-list 可能为空。
C++ 定义两种特殊的构造函数(默认构造函数和复制构造函数),如下表所述。

默认构造函数和复制构造函数

默认构造函数可在没有参数的情况下调用。但是,如果所有参数都有默认值,则可以用参数列表声明默认构造函数。同样,复制构造函数必须接受对相同类类型的引用的单一参数。可以提供多个参数,前提是所有后续参数都有默认值。
如果未提供任何构造函数,则编译器将尝试生成默认构造函数。如果未提供复制构造函数,则编译器将尝试生成一个。这些编译器生成的构造函数被视为公共成员函数。如果使用属于对象但不属于引用的第一个参数指定复制构造函数,则将生成错误。
编译器生成的默认构造函数将设置对象(如上文所述,初始化 vftables 和 vbtables),并调用基类和成员的默认构造函数,但是它不执行任何其他操作。仅当基类和成员构造函数存在、可访问并且无歧义时才会调用它们。
编译器生成的复制构造函数将设置新的对象,并对要复制的对象的内容按成员复制。如果基类或成员构造函数存在,则将调用它们;否则将执行按位复制。
如果类 type 的所有基类和成员类均具有接受 const 参数的复制构造函数,则编译器生成的复制构造函数将接受 const type& 类型的单个参数。否则,编译器生成的复制构造函数将接受 type& 类型的单个参数。
您可以使用构造函数初始化 const 或 volatile 对象,但是,构造函数本身不能声明为 const 或 volatile。构造函数的唯一合法存储类是 inline;将任何其他存储类修饰符(包括 __declspec 关键字)与构造函数一起使用将导致编译器错误。
stdcall 调用约定用于使用 __stdcall 关键字声明的静态成员函数和全局函数,且不使用变量参数列表。对非静态成员函数(如构造函数)使用 __stdcall 关键字时,编译器将使用 thiscall 调用约定。
基类的构造函数不由派生类继承。创建派生类类型的对象时,该对象将从基类组件开始进行构造;然后移到派生类组件。由于整个对象有一部分已初始化,因此编译器使用每个基类的构造函数(虚拟派生的情况除外,如初始化基类中所述)。
显式调用构造函数
可以在程序中显式调用构造函数来创建给定类型的对象。例如,若要创建描述某行末尾的两个 Point 对象,请编写以下代码:

DrawLine( Point( 13, 22 ), Point( 87, 91 ) );

创建类型 Point 的两个对象,将其传递给函数 DrawLine,并在表达式(函数调用)的末尾将其销毁。
在其中显式调用构造函数的另一个上下文正在进行初始化:

Point pt = Point( 7, 11 );

使用接受类型为 Point 的两个参数的构造函数来创建和初始化类型为 int 的对象。
通过显式调用构造函数创建的对象(如上面的两个示例)未进行命名,并且该对象具有在其中创建它们的表达式的生存期。 临时对象中更详细地讨论了这一点。
通常,从构造函数的内部调用所有成员函数是安全的,因为该对象在用户代码的第一行执行之前已完全设置(已初始化虚拟表等)。但是,在构造或析构期间,成员函数调用抽象基类的虚拟成员函数可能是不安全的。
构造函数可以调用虚函数。调用虚函数时,调用的函数将是为构造函数自己的类定义的函数(或从其基类继承)。以下示例演示从构造函数的内部调用虚函数时发生的情况:

// specl_calling_virtual_functions.cpp
// compile with: /EHsc
#include <iostream>

using namespace std;
class Base
{
public:
  Base();       // Default constructor.
  virtual void f();  // Virtual member function.
};

Base::Base()
{
  cout << "Constructing Base sub-object\n";
  f();        // Call virtual member function
}            // from inside constructor.

void Base::f()
{
  cout << "Called Base::f()\n";
}

class Derived : public Base
{
public:
  Derived();     // Default constructor.
  void f();      // Implementation of virtual
};           // function f for this class.

Derived::Derived()
{
  cout << "Constructing Derived object\n";
}

void Derived::f()
{
  cout << "Called Derived::f()\n";
}

int main()
{
  Derived d;
}

在运行前面的程序时,声明 Derived d 将产生以下事件序列:
调用类 Derived (Derived::Derived) 的构造函数。
在输入 Derived 类的构造函数的主体之前,调用类 Base (Base::Base) 的构造函数。
Base::Base 调用函数 f,该函数是一个虚函数。通常,将调用 Derived::f,因为对象 d 属于类型 Derived。由于 Base::Base 函数是构造函数,因此该对象不属于 Derived 类型,并且将调用 Base::f。

时间: 2016-01-18

C++详解默认参数的构造函数及简单实例代码

现在给大家介绍下 有默认参数的构造函数: 大家知道函数获取形参的时候是通过函数调用时在实参里获得的,因此我们必须保证 实参的个数 和 形参的个数必须相同.而且有些情况下我们对于实参或许都是个固定的值.例如 我们需要计算长方形的面积 长x宽 但是用户可以不输入长 而且如果用户指定的情况下默认的长为 3,但是如果用户指定了则使用用户指定的宽 这就是用到默认参数了! 代码: #include <iostream> using namespace std; int area(int l,int w=3

详解C++中对构造函数和赋值运算符的复制和移动操作

复制构造函数和复制赋值运算符 从 C++ 11 中开始,该语言支持两种类型的分配:复制赋值和移动赋值. 在本文中,"赋值"意味着复制赋值,除非有其他显式声明. 赋值操作和初始化操作都会导致对象被复制. 赋值:在将一个对象的值赋给另一个对象时,第一个对象将复制到第二个对象中. 因此, Point a, b; ... a = b; 导致 b 的值被复制到 a 中. 初始化:在以下情况下将进行初始化:声明新对象.参数通过值传递给函数或值通过值从函数返回. 您可以为类类型的对象定义"

C++ 类的构造函数详解及实例

C++ 类的构造函数 默认构造函数 如果你定义一个类,并且没有给它定义构造函数.编译器会为这个类提供默认的构造函数.如果你提供了构造函数,编译器是不会再为你提供一个默认构造函数的.编译器提供的默认构造函数什么都没做.类的成员变量将遵守默认的初始化规则. 编译器提供的默认构造函数的初始化规则: 在栈和堆中的类对象的内置或复合类型成员变量将为脏数据: 在全局变量区的类对象的内置或复合类型成员变量初始化为0: 类对象成员将调用默认的构造函数来初始化: #include <iostream> usin

详解C++ 拷贝构造函数和赋值运算符

本文主要介绍了拷贝构造函数和赋值运算符的区别,以及在什么时候调用拷贝构造函数.什么情况下调用赋值运算符.最后,简单的分析了下深拷贝和浅拷贝的问题. 拷贝构造函数和赋值运算符 在默认情况下(用户没有定义,但是也没有显式的删除),编译器会自动的隐式生成一个拷贝构造函数和赋值运算符.但用户可以使用delete来指定不生成拷贝构造函数和赋值运算符,这样的对象就不能通过值传递,也不能进行赋值运算. class Person { public: Person(const Person& p) = dele

详谈C++何时需要定义赋值/复制构造函数

继承和动态内存分配 假设基类使用了动态内存分配,而且定义了析构函数.复制构造函数和赋值函数,但是在派生类中没有使用动态内存分配,那么在派生类中不需要显示定义析构函数.复制构造函数和赋值函数. 当基类和派生类采用动态内存分配时,派生类的析构函数.复制构造函数.赋值运算符都必须使用相应的基类方法来处理基类元素.这种要求是通过三种不同的方式来满足的.对于析构函数.这是自动完成的,也就是说在派生类的析构函数中无需显示调用基类的析构函数.对于构造函数,这是通过在初始化成员列表中调用基类的复制构造函数来完成

C++中的构造函数与析造函数详解

C++中的构造函数与析造函数详解  构造函数的概念 (1)构造函数是特殊的成员函数         (2)当创建类类型的新对象时,系统自动会调用构造函数         (3) 构造函数是为了保证对象的每个数据成员都被正确的初始化.         创建构造函数的注意事项: (1) 函数名与类名相同:         (2) 没有返回类型,返回类型也不能是void型         (3) 构造函数通常情况下声明为public,否则不能像其它成员函数那样被显示的调用         (4) 构造

pytorch中tensor.expand()和tensor.expand_as()函数详解

tensor.expend()函数 >>> import torch >>> a=torch.tensor([[2],[3],[4]]) >>> print(a.size()) torch.Size([3, 1]) >>> a.expand(3,2) tensor([[2, 2], [3, 3], [4, 4]]) >>> a tensor([[2], [3], [4]]) 可以看出expand()函数括号里面为变形

php array_walk 对数组中的每个元素应用用户自定义函数详解

php array_walk 对数组中的每个元素应用用户自定义函数 array_walk 使用用户自定义函数对数组中的每个元素做回调处理 基本语法 bool array_walk ( array &$array , callable $funcname [, mixed $userdata = NULL ] ) 将用户自定义函数 funcname 应用到 array 数组中的每个单元. array_walk() 不会受到 array 内部数组指针的影响. array_walk() 会遍历整个数组

Lua中编译执行代码相关的函数详解

可以说Lua之所以称为是一种解释型的语言,正是因为有诸如load这样的函数,因为这样的函数使得Lua可以执行动态生成的代码.下面具体来分析这些函数. load函数 load函数原型如下: 复制代码 代码如下: load (chunk [, chunkname [, mode [, env]]]) 该函数加载一个chunk,如果没有错误,则返回一个函数.如果传入chunk的值是一个字符串,则就加载这个字符串:如果传入chunk的值是一个函数,则这个函数必须返回一个字符串,并且load会一直调用这个

JS中如何实现Laravel的route函数详解

大家应该都知道在Laravel的路由模块里,我们可以给每一个路由设定一个名字,比如: Route::get('/blog/{blog}', 'BlogController@show')->name('blog.show') 然后就可以通过 route('blog.show', ['blog' => 1]) 来获取到这个路由的访问地址,后端跳转可以用 return redirect()->route('blog.show', ['blog' => 1]); 这样做的好处是如果发生ur

javascript中Array()数组函数详解

在程序语言中数组的重要性不言而喻,JavaScript中数组也是最常使用的对象之一,数组是值的有序集合,由于弱类型的原因,JavaScript中数组十分灵活.强大,不像是Java等强类型高级语言数组只能存放同一类型或其子类型元素,JavaScript在同一个数组中可以存放多种类型的元素,而且是长度也是可以动态调整的,可以随着数据增加或减少自动对数组长度做更改. Array()是一个用来构建数组的内建构造器函数.数组主要由如下三种创建方式: array = new Array() array =

对python中的高效迭代器函数详解

python中内置的库中有个itertools,可以满足我们在编程中绝大多数需要迭代的场合,当然也可以自己造轮子,但是有现成的好用的轮子不妨也学习一下,看哪个用的顺手~ 首先还是要先import一下: #import itertools from itertools import * #最好使用时用上面那个,不过下面的是为了演示比较 常用的,所以就直接全部导入了 一.无限迭代器: 由于这些都是无限迭代器,因此使用的时候都要设置终止条件,不然会一直运行下去,也就不是我们想要的结果了. 1.coun

COM组件中调用JavaScript函数详解及实例

COM组件中调用JavaScript函数详解及实例 要求是很简单的,即有COM组件A在IE中运行,使用JavaScript(JS)调用A的方法longCalc(),该方法是一个耗时的操作,要求通知IE当前的进度.这就要求使用回调函数,设其名称为scriptCallbackFunc.实现这个技术很简单: 1 .组件方(C++) 组件A 的方法在IDL中定义: [id(2)] HRESULT longCalc([in] DOUBLE v1, [in] DOUBLE v2, [in, optional

ASP 中 DateDiff 函数详解 主要实现两日期加减操作

ASP 中 DateDiff 函数详解DateDiff 函数 描述  返回两个日期之间的时间间隔.  语法  DateDiff(interval, date1, date2 [,firstdayofweek][, firstweekofyear]])  DateDiff 函数的语法有以下参数: 参数 描述  interval 必选.字符串表达式,表示用于计算 date1 和 date2 之间的时间间隔.有关数值,请参阅"设置"部分.  date1, date2 必选.日期表达式.用于计

Linux 中可重入函数与不可重入函数详解

Linux 中可重入函数与不可重入函数详解 可重入函数和不可重入函数说起来有点拗口,其实写过多进程(线程)程序的人肯定很快就能明白这两种函数是个神马东西.下面是我对这两个函数的理解: 可重入函数可以理解为是能被中断的函数,并且它被中断返回后也不会出现什么错误. 不可重入函数可以理解为如果函数被中断的话,就会出现不可预料的错误.这是因为函数中使用了一些系统资源,比如全局变量区,中断向量表之类的.比如多个进程同时对一个文件进行写操作,如果没有同步机制的话,对文件的写入就会变得难以控制. 在多进程(线