【初学】无法从静态上下文中引用非静态变量 this

师乙己 2017-12-03 10:56:46

想用变量方法打印一个乘法表，然后报错了请问代码有什么问题吗？



import java.util.*;

public class cyff

{

	public static void main (String args [])

	{

		Scanner cfbn=new Scanner(System.in);

		Mul mul1=new Mul();

		int n=cfbn.nextInt();

		System.out.println(mul1.cfb(n));

	}

	class Mul

	{

		public void cfb(int x)

		{

			for (int h;h<=x;h++)

			{

				for (int l;l<=h;l++)

				{

					int result=h*l;

					System.out.print(h+"×"+l+"="+result);

					System.out.print("  ");

				}

				System.out.println();

			}

		}

	}

}

...全文

102 3 打赏收藏转发到动态举报

写回复

3 条回复

切换为时间正序

请发表友善的回复…

发表回复

师乙己 2017-12-03

打赏
举报

回复


import java.util.*;
public class cyff
{
	public static void main (String args [])
	{
		Mul mul1=new Mul();
		mul1.cfb();
	}
}
		class Mul
	{
		public void cfb()
		{
			Scanner cfbn=new Scanner(System.in);
			int x=cfbn.nextInt();
			for (int h=1;h<=x;h++)
			{
				for (int l=1;l<=h;l++)
				{
					int result=h*l;
					System.out.print(h+"×"+l+"="+result);
					System.out.print("  ");
				}
				System.out.println();
			}
		}
	}

师乙己 2017-12-03

打赏
举报

回复

引用 1 楼 pany1209 的回复:

太几把搞了，语法都没学好，Mul写到cyff外面,方法没有返回值，使用System.out.println干啥？？？

谢谢，重写了一下，大佬打错了吧，刚才写cyff里面了，刚试了下写到cyff外面跟main里面可以- -[ code=java] import java.util.*; public class cyff { public static void main (String args []) { Mul mul1=new Mul(); mul1.cfb(); } } class Mul { public void cfb() { Scanner cfbn=new Scanner(System.in); int x=cfbn.nextInt(); for (int h=1;h<=x;h++) { for (int l=1;l<=h;l++) { int result=h*l; System.out.print(h+"×"+l+"="+result); System.out.print(" "); } System.out.println(); } } } [/code]

李德胜1995 2017-12-03

打赏
举报

回复

太几把搞了，语法都没学好，Mul写到cyff外面,方法没有返回值，使用System.out.println干啥？？？

在一小时内学会 C#。使用例程，简单却完整的探索 C# 语言的构造和特点。本文特别适合有 C++ 基础却没有太多精力学习 C# 的读者。关于作者 Aisha Ikram 我现在在英国一家软件公司任技术带头人。我是计算机科学的硕士。我主要使用 .NET 1.1/2.0, C#, VB.NET, ASP.NET, VC++ 6, MFC, ATL, COM/DCOM, SQL Server 2000/2005等。最近我在学习 .NET 3.x 的全部内容。我的免费源代码和文章网站是 http://aishai.netfirms.com 职业：团队带头人位置：英国简介 C# 是一种具有 C++ 特性，Java 样式及 BASIC 快速建模特性的编程语言。如果你已经知晓 C++ 语言，本文将在不到一小时的时间内带你快速浏览 C# 的语法。如果熟悉 Java 语言，Java 的编程结构、打包和垃圾回收的概念肯定对你快速学习 C# 大有帮助。所以我在讨论 C# 语言构造的时候会假设你知道 C++。本文通过一系列例程以简短但全面的方式讨论了 C# 语言构造和特性，所以你仅需略览代码片刻，即可了解其概念。注意：本文不是为 C# 宗师而写。有很多初学者的 C# 文章，这只是其中之一。接下来关于 C# 的讨论主题： ? 编程结构 ? 命名空间 ? 数据类型 ? 变量 ? 运算符与表达式 ? 枚举 ? 语句 ? 类与结构 ? 修饰符 ? 属性 ? 接口 ? 函数参数 ? 数组 ? 索引器 ? 装箱与拆箱 ? 委托 ? 继承与多态以下主题不会进行讨论： ? C++ 与 C# 的共同点 ? 诸如垃圾回收、线程、文件处理等概念 ? 数据类型转换 ? 异常处理 ? .NET 库编程结构和 C++ 一样，C# 是大小写敏感的。半角分号（;）是语句分隔符。和 C++ 有所区别的是，C# 中没有单独的声明（头）和实现（CPP）文件。所有代码（类声明和实现）都放在扩展名为 cs 的单一文件中。看看 C# 中的 Hello World 程序。复制内容到剪贴板代码: using System; namespace MyNameSpace { class HelloWorld { static void Main(string[] args) { Console.WriteLine ("Hello World"); } } } C# 中所有内容都打包在类中，而所有的类又打包在命名空间中（正如文件存与文件夹中）。和 C++ 一样，有一个主函数作为你程序的入口点。C++ 的主函数名为 main，而 C# 中是大写 M 打头的 Main。类块或结构定义之后没有必要再加一个半角分号。C++ 中是这样，但 C# 不要求。命名空间每个类都打包于一个命名空间。命名空间的概念和 C++ 完全一样，但我们在 C# 中比在 C++ 中更加频繁的使用命名空间。你可以用点（.）定界符访问命名空间中的类。上面的 Hello World 程序中，MyNameSpace 是其命名空间。现在思考当你要从其他命名空间的类中访问 HelloWorld 类。复制内容到剪贴板代码: using System; namespace AnotherNameSpace { class AnotherClass { public void Func() { Console.WriteLine ("Hello World"); } } } 现在在你的 HelloWorld 类中你可以这样访问：复制内容到剪贴板代码: using System; using AnotherNameSpace; // 你可以增加这条语句 namespace MyNameSpace { class HelloWorld { static void Main(string[] args) { AnotherClass obj = new AnotherClass(); obj.Func(); } } } 在 .NET 库中，System 是包含其他命名空间的顶层命名空间。默认情况下存在一个全局命名空间，所以在命名空间外定义的类直接进到此全局命名空间中，因而你可以不用定界符访问此类。你同样可以定义嵌套命名空间。 Using #include 指示符被后跟命名空间名的 using 关键字代替了。正如上面的 using System。System 是最基层的命名空间，所有其他命名空间和类都包含于其中。System 命名空间中所有对象的基类是 Object。变量除了以下差异，C# 中的变量几乎和 C++ 中一样： 1. C# 中（不同于 C++）的变量，总是需要你在访问它们前先进行初始化，否则你将遇到编译时错误。故而，不可能访问未初始化的变量。 2. 你不能在 C# 中访问一个“挂起”指针。 3. 超出数组边界的表达式索引值同样不可访问。 4. C# 中没有全局变量或全局函数，取而代之的是通过静态函数和静态变量完成的。数据类型所有 C# 的类型都是从 object 类继承的。有两种数据类型： 1. 基本/内建类型 2. 用户定义类型以下是 C# 内建类型的列表：类型字节描述 byte 1 unsigned byte sbyte 1 signed byte short 2 signed short ushort 2 unsigned short int 4 signed integer uint 4 unsigned integer long 8 signed long ulong 8 unsigned long float 4 floating point number double 8 double precision number decimal 8 fixed precision number string - Unicode string char - Unicode char bool true, false boolean 注意：C# 的类型范围和 C++ 不同。例如：long 在 C++ 中是 4 字节而在 C# 中是 8 字节。bool 和 string 类型均和 C++ 不同。bool 仅接受真、假而非任意整数。用户定义类型文件包含： 1. 类（class） 2. 结构（struct） 3. 接口（interface）以下类型继承时均分配内存： 1. 值类型 2. 参考类型值类型值类型是在堆栈中分配的数据类型。它们包括了： ? 除字符串，所有基本和内建类型 ? 结构 ? 枚举类型引用类型引用类型在堆（heap）中分配内存且当其不再使用时，将自动进行垃圾清理。和 C++ 要求用户显示创建 delete 运算符不一样，它们使用新运算符创建，且没有 delete 运算符。在 C# 中它们自动由垃圾回收系统回收。引用类型包括： ? 类 ? 接口 ? 集合类型如数组 ? 字符串枚举 C# 中的枚举和 C++ 完全一样。通过关键字 enum 定义。例子：复制内容到剪贴板代码: enum Weekdays { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday } 类与结构除了内存分配的不同外，类和结构就和 C++ 中的情况一样。类的对象在堆中分配，并使用 new 关键字创建。而结构是在栈（stack）中进行分配。C# 中的结构属于轻量级快速数据类型。当需要大型数据类型时，你应该创建类。例子：复制内容到剪贴板代码: struct Date { int day; int month; int year; } class Date { int day; int month; int year; string weekday; string monthName; public int GetDay() { return day; } public int GetMonth() { return month; } public int GetYear() { return year; } public void SetDay(int Day) { day = Day ; } public void SetMonth(int Month) { month = Month; } public void SetYear(int Year) { year = Year; } public bool IsLeapYear() { return (year/4 == 0); } public void SetDate (int day, int month, int year) { } ... } 属性如果你熟悉 C++ 面向对象的方法，你一定对属性有自己的认识。对 C++ 来说，前面例子中 Date 类的属性就是 day、month 和 year，而你添加了 Get 和 Set 方法。C# 提供了一种更加便捷、简单而又直接的属性访问方式。所以上面的类应该写成这样：复制内容到剪贴板代码: using System; class Date { public int Day{ get { return day; } set { day = value; } } int day; public int Month{ get { return month; } set { month = value; } } int month; public int Year{ get { return year; } set { year = value; } } int year; public bool IsLeapYear(int year) { return year%4== 0 ? true: false; } public void SetDate (int day, int month, int year) { this.day = day; this.month = month; this.year = year; } } 这里是你 get 和 set 属性的方法：复制内容到剪贴板代码: class User { public static void Main() { Date date = new Date(); date.Day = 27; date.Month = 6; date.Year = 2003; Console.WriteLine ("Date: {0}/{1}/{2}", date.Day, date.Month, date.Year); } } 修饰符你必须知道 C++ 中常用的 public、private 和 protected 修饰符。我将在这里讨论一些 C# 引入的新的修饰符。 readonly readonly 修饰符仅用于修饰类的数据成员。正如其名字说的，一旦它们已经进行了写操作、直接初始化或在构造函数中对其进行了赋值，readonly 数据成员就只能对其进行读取。readonly 和 const 数据成员不同之处在于 const 要求你在声明时进行直接初始化。看下面的例程：复制内容到剪贴板代码: class MyClass { const int constInt = 100; //直接进行 readonly int myInt = 5; //直接进行 readonly int myInt2; public MyClass() { myInt2 = 8; //间接进行 } public Func() { myInt = 7; //非法 Console.WriteLine(myInt2.ToString()); } } sealed 带有 sealed 修饰符的类不允许你从它继承任何类。所以如果你不想一个类被继承，你可以对该类使用 sealed 关键字。复制内容到剪贴板代码: sealed class CanNotbeTheParent { int a = 5; } unsafe 你可以使用 unsafe 修饰符在 C# 中定义一个不安全上下文。在不安全上下文中，你可以插入不安全代码，如 C++ 的指针等。参见以下代码：复制内容到剪贴板代码: public unsafe MyFunction( int * pInt, double* pDouble) { int* pAnotherInt = new int; *pAnotherInt = 10; pInt = pAnotherInt; ... *pDouble = 8.9; } 接口如果你有 COM 的思想，你马上就知道我在说什么了。接口是只包含函数签名而在子类中实现的抽象基类。在 C# 中，你可以用 interface 关键字声明这样的接口类。.NET 就是基于这样的接口的。C# 中你不能对类进行多重继承——这在 C++ 中是允许的。通过接口，多重继承的精髓得以实现。即你的子类可以实现多重接口。（译注：由此可以实现多重继承）复制内容到剪贴板代码: using System; interface myDrawing { int originx { get; set; } int originy { get; set; } void Draw(object shape); } class Shape: myDrawing { int OriX; int OriY; public int originx { get{ return OriX; } set{ OriX = value; } } public int originy { get{ return OriY; } set{ OriY = value; } } public void Draw(object shape) { ... // 做要做的事 } // 类自身的方法 public void MoveShape(int newX, int newY) { ..... } } 数组数组在 C# 中比 C++ 中要高级很多。数组分配于堆中，所以是引用类型的。你不能访问数组边界外的元素。所以 C# 防止你引发那种 bug。同时也提供了迭代数组元素的帮助函数。foreach 是这样的迭代语句之一。C++ 和 C# 数组的语法差异在于：方括号在类型后面而不是在变量名后面创建元素使用 new 运算符 C# 支持一维、多维和交错数组（数组的数组）例子：复制内容到剪贴板代码: int[] array = new int[10]; // int 型一维数组 for (int i = 0; i < array.Length; i++) array = i; int[,] array2 = new int[5,10]; // int 型二维数组 array2[1,2] = 5; int[,,] array3 = new int[5,10,5]; // int 型三维数组 array3[0,2,4] = 9; int[][] arrayOfarray = new int[2]; // int 型交错数组 - 数组的数组 arrayOfarray[0] = new int[4]; arrayOfarray[0] = new int[] {1,2,15}; 索引器索引器用于书写一个可以通过使用 [] 像数组一样直接访问集合元素的方法。你所需要的只是指定待访问实例或元素的索引。索引器的语法和类属性语法相同，除了接受作为元素索引的输入参数外。例子：注意：CollectionBase 是用于建立集合的库类。List 是 CollectionBase 中用于存放集合列表的受保护成员。复制内容到剪贴板代码: class Shapes: CollectionBase { public void add(Shape shp) { List.Add(shp); } //indexer public Shape this[int index] { get { return (Shape) List[index]; } set { List[index] = value ; } } } 装箱/拆箱装箱的思想在 C# 中是创新的。正如前面提到的，所有的数据类型，无论是内建的还是用户定义的，都是从 System 命名空间的基类 object 继承的。所以基础的或是原始的类型打包为一个对象称为装箱，相反的处理称为拆箱。例子：复制内容到剪贴板代码: class Test { static void Main() { int myInt = 12; object obj = myInt ; // 装箱 int myInt2 = (int) obj; // 拆箱 } } 例程展示了装箱和拆箱两个过程。一个 int 值可以被转换为对象，并且能够再次转换回 int。当某种值类型的变量需要被转换为一个引用类型时，便会产生一个对象箱保存该值。拆箱则完全相反。当某个对象箱被转换回其原值类型时，该值从箱中拷贝至适当的存储空间。函数参数 C# 中的参数有三种类型： 1. 按值传递/输入参数 2. 按引用传递/输入-输出参数 3. 输出参数如果你有 COM 接口的思想，而且还是参数类型的，你会很容易理解 C# 的参数类型。按值传递/输入参数值参数的概念和 C++ 中一样。传递的值复制到了新的地方并传递给函数。例子：复制内容到剪贴板代码: SetDay(5); ... void SetDay(int day) { .... } 按引用传递/输入-输出参数 C++ 中的引用参数是通过指针或引用运算符 & 传递的。C# 中的引用参数更不易出错。你可以传递一个引用地址，你传递一个输入的值并通过函数得到一个输出的值。因此引用参数也被称为输入-输出参数。你不能将未初始化的引用参数传递给函数。C# 使用关键字 ref 指定引用参数。你同时还必须在传递参数给要求引用参数的函数时使用关键字 ref。例子：复制内容到剪贴板代码: int a= 5; FunctionA(ref a); // 使用 ref，否则将引发编译时错误 Console.WriteLine(a); // 打印 20 复制内容到剪贴板代码: void FunctionA(ref int Val) { int x= Val; Val = x* 4; } 输出参数输出参数是只从函数返回值的参数。输入值不要求。C# 使用关键字 out 表示输出参数。例子：复制内容到剪贴板代码: int Val; GetNodeValue(Val); 复制内容到剪贴板代码: bool GetNodeValue(out int Val) { Val = value; return true; } 参数和数组的数量变化 C# 中的数组使用关键字 params 进行传递。一个数组类型的参数必须总是函数最右边的参数。只有一个参数可以是数组类型。你可以传送任意数量的元素作为数组类型的参数。看了下面的例子你可以更好的理解：注意：使用数组是 C# 提供用于可选或可变数量参数的唯一途径。例子：复制内容到剪贴板代码: void Func(params int[] array) { Console.WriteLine("number of elements {0}", array.Length); } 复制内容到剪贴板代码: Func(); // 打印 0 Func(5); // 打印 1 Func(7,9); // 打印 2 Func(new int[] {3,8,10}); // 打印 3 int[] array = new int[8] {1,3,4,5,5,6,7,5}; Func(array); // 打印 8 运算符与表达式运算符和表达式跟 C++ 中完全一致。然而同时也添加了一些新的有用的运算符。有些在这里进行了讨论。 is 运算符 is 运算符是用于检查操作数类型是否相等或可以转换。is 运算符特别适合用于多态的情形。is 运算符使用两个操作数，其结果是布尔值。参考例子：复制内容到剪贴板代码: void function(object param) { if(param is ClassA) //做要做的事 else if(param is MyStruct) //做要做的事 } } as 运算符 as 运算符检查操作数的类型是否可转换或是相等（as 是由 is 运算符完成的），如果是，则处理结果是已转换或已装箱的对象（如果操作数可以装箱为目标类型，参考装箱/拆箱）。如果对象不是可转换的或可装箱的，返回值为 null。看看下面的例子以更好的理解这个概念。复制内容到剪贴板代码: Shape shp = new Shape(); Vehicle veh = shp as Vehicle; // 返回 null，类型不可转换 Circle cir = new Circle(); Shape shp = cir; Circle cir2 = shp as Circle; //将进行转换 object[] objects = new object[2]; objects[0] = "Aisha"; object[1] = new Shape(); string str; for(int i=0; i&< objects.Length; i++) { str = objects as string; if(str == null) Console.WriteLine("can not be converted"); else Console.WriteLine("{0}",str); } 复制内容到剪贴板代码: Output: Aisha can not be converted 语句除了些许附加的新语句和修改外，C# 的语句和 C++ 的基本一致。以下是新的语句： foreach 用于迭代数组等集合。例子：复制内容到剪贴板代码: foreach (string s in array) Console.WriteLine(s); lock 在线程中使代码块称为重点部分。（译注：lock 关键字将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句，然后释放该锁。lock 确保当一个线程位于代码的临界区时，另一个线程不进入临界区。如果其他线程试图进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放。） checked/unchecked 用于数字操作中的溢出检查。例子：复制内容到剪贴板代码: int x = Int32.MaxValue; x++; // 溢出检查 { x++; // 异常 } unchecked { x++; // 溢出 } 下面的语句已修改：（译注：原文如此，疑为作者笔误） Switch Switch 语句在 C# 中修改过。 1.现在在执行一条 case 语句后，程序流不能跳至下一 case 语句。之前在 C++ 中这是可以的。例子：复制内容到剪贴板代码: int var = 100; switch (var) { case 100: Console.WriteLine(""); // 这里没有 break case 200: Console.WriteLine(""); break; } C++ 的输出：复制内容到剪贴板代码: 而在 C# 中你将得到一个编译时错误：复制内容到剪贴板代码: error CS0163: Control cannot fall through from one case label ('case 100:') to another 2.然而你可以像在 C++ 中一样这么用：复制内容到剪贴板代码: switch (var) { case 100: case 200: Console.WriteLine("100 or 200"); break; } 3.你还可以用常数变量作为 case 值：例子：复制内容到剪贴板代码: const string WeekEnd = "Sunday"; const string WeekDay1 = "Monday"; .... string WeekDay = Console.ReadLine(); switch (WeekDay ) { case WeekEnd: Console.WriteLine("It's weekend!!"); break; case WeekDay1: Console.WriteLine("It's Monday"); break; } 委托委托让我们可以把函数引用保存在变量中。这就像在 C++ 中使用 typedef 保存函数指针一样。委托使用关键字 delegate 声明。看看这个例子，你就能理解什么是委托：例子：复制内容到剪贴板代码: delegate int Operation(int val1, int val2); public int Add(int val1, int val2) { return val1 + val2; } public int Subtract (int val1, int val2) { return val1- val2; } public void Perform() { Operation Oper; Console.WriteLine("Enter + or - "); string optor = Console.ReadLine(); Console.WriteLine("Enter 2 operands"); string opnd1 = Console.ReadLine(); string opnd2 = Console.ReadLine(); int val1 = Convert.ToInt32 (opnd1); int val2 = Convert.ToInt32 (opnd2); if (optor == "+") Oper = new Operation(Add); else Oper = new Operation(Subtract); Console.WriteLine(" Result = {0}", Oper(val1, val2)); } 继承与多态 C# 只允许单一继承。多重继承可以通过接口达到。例子：复制内容到剪贴板代码: class Parent{ } class Child : Parent 虚函数虚函数在 C# 中同样是用于实现多态的概念的，除了你要使用 override 关键字在子类中实现虚函数外。父类使用同样的 virtual 关键字。每个重写虚函数的类都使用 override 关键字。（译注：作者所说的“同样”，“除……外”都是针对 C# 和 C++ 而言的）复制内容到剪贴板代码: class Shape { public virtual void Draw() { Console.WriteLine("Shape.Draw") ; } } class Rectangle : Shape { public override void Draw() { Console.WriteLine("Rectangle.Draw"); } } class Square : Rectangle { public override void Draw() { Console.WriteLine("Square.Draw"); } } class MainClass { static void Main(string[] args) { Shape[] shp = new Shape[3]; Rectangle rect = new Rectangle(); shp[0] = new Shape(); shp[1] = rect; shp[2] = new Square(); shp[0].Draw(); shp[1].Draw(); shp[2].Draw(); } } Output: Shape.Draw Rectangle.Draw Square.Draw 使用“new”隐藏父类函数你可以隐藏基类中的函数而在子类中定义其新版本。关键字 new 用于声明新的版本。思考下面的例子，该例是上一例子的修改版本。注意输出，我用关键字 new 替换了 Rectangle 类中的关键字 override。复制内容到剪贴板代码: class Shape { public virtual void Draw() { Console.WriteLine("Shape.Draw") ; } } class Rectangle : Shape { public new void Draw() { Console.WriteLine("Rectangle.Draw"); } } class Square : Rectangle { //这里不用 override public new void Draw() { Console.WriteLine("Square.Draw"); } } class MainClass { static void Main(string[] args) { Console.WriteLine("Using Polymorphism:"); Shape[] shp = new Shape[3]; Rectangle rect = new Rectangle(); shp[0] = new Shape(); shp[1] = rect; shp[2] = new Square(); shp[0].Draw(); shp[1].Draw(); shp[2].Draw(); Console.WriteLine("Using without Polymorphism:"); rect.Draw(); Square sqr = new Square(); sqr.Draw(); } } Output: Using Polymorphism Shape.Draw Shape.Draw Shape.Draw Using without Polymorphism: Rectangle.Draw Square.Draw 多态性认为 Rectangle 类的 Draw 方法是和 Shape 类的 Draw 方法不同的另一个方法，而不是认为是其多态实现。所以为了防止父类和子类间的命名冲突，我们只有使用 new 修饰符。注意：你不能在一个类中使用一个方法的两个版本，一个用 new 修饰符，另一个用 override 或 virtual。就像在上面的例子中，我不能在 Rectangle 类中增加另一个名为 Draw 的方法，因为它是一个 virtual 或 override 的方法。同样在 Square 类中，我也不能重写 Shape 类的虚方法 Draw。调用基类成员如果子类的数据成员和基类中的有同样的名字，为了避免命名冲突，基类成员和函数使用 base 关键字进行访问。看看下面的例子，基类构造函数是如何调用的，而数据成员又是如何使用的。复制内容到剪贴板代码: public Child(int val) :base(val) { myVar = 5; base.myVar; } OR public Child(int val) { base(val); myVar = 5 ; base.myVar; } 前景展望本文仅仅是作为 C# 语言的一个快速浏览，以便你可以熟悉该语言的一些特性。尽管我尝试用实例以一种简短而全面的方式讨论了 C# 几乎所有的主要概念，但我认为还是有很多内容需要增加和讨论的。以后，我会增加更多的没有讨论过的命令和概念，包括事件等。我还想给初学者写一下怎么用 C# 进行 Windows 编程。参考文献：我们都知道的 MSDN Tom Archer 著，Inside C# Eric Gunnerson 著，A Programmer's Introduction to C# Karli Watson 著，Beginning C# O'Reilly（奥莱利出版），Programming C# 修改： 2003年6月12日：按引用传递/输入-输出参数一节中增加了 ref 关键字 2003年6月20日：为可选参数增加了一条注意事项，纠正了交错数组例子中赋值运算符的笔误许可本文及其任何关联的源代码和文件均以 The Code Project Open License (CPOL)执行。（译注：代码计划网站公开许可）

CruiseYoung提供的带有详细书签的电子书籍目录 http://blog.csdn.net/fksec/article/details/7888251 该资料是《Visual C++ 2010入门经典(第5版)》的源代码及课后练习答案对应的书籍资料见: Visual C++ 2010入门经典(第5版) 基本信息原书名： Ivor Horton's Beginning Visual C++ 2010 原出版社： Wrox 作者： (美)Ivor Horton 译者：苏正泉李文娟出版社：清华大学出版社 ISBN：9787302239994 上架时间：2010-12-20 出版日期：2010 年12月开本：16开页码：1011 版次：5-1 编辑推荐　　本书针对visual c++ 2010版本做了全面更新，介绍了最新开发环境，讲述了如何使用visual c++构建真实世界的应用程序。　　采用了容易理解的讲授方法，并提供了详尽的示例，旨在帮助读者掌握编程技巧内容简介　　作者ivor horton采用了容易理解的讲授方法，并提供了详尽的示例，帮助读者迅速地成为一名优秀的c++编程人员。《visual c++ 2010入门经典(第5版)》针对visual c++ 2010版本进行了全面更新，介绍了最新的开发环境和如何使用visual c++构建现实世界中的应用程序。拥有本书，您就迈向了通往使用两种c++版本编写应用程序的成功之路，并成为一名优秀的c++编程人员。　　主要内容　　 ·使用visual c++ 2010支持的两种c++语言技术讲述c++编程的基础知识　　 ·分享c++程序的错误查找技术，并介绍通用的调试原则讨论每一个windows应用程序的结构和基本元素　　 ·举例说明如何使用mfc开发本地windows应用程序　　 ·指导读者用c++和c++／cli设计和创建大量的windows应用程序　　 ·为帮助读者掌握编程技巧，提供了大量可运行的示例和练习作译者　　Ivor Horton是撰著Java、C和C++编程语言图书的杰出作家之一。大家一致认为，他的著作独具风格，无论是编程新手，还是经验丰富的编程人员，都很容易理解其内容。在个人实践中，Ivor Horton也是一名系统顾问。他从事程序设计教学工作已经超过了25年。　　苏正泉，1995年毕业于解放军信息工程学院计算机及应用专业，高级工程师。在IT项目管理、软件开发、系统管理和网络管理方面都有非常丰富的实践经验。曾发表过多篇计算机专业论文，并翻译过多部计算机专业技术书籍。　　李文娟，中国石油大学（华东）硕士,现供职于国家行政学院,工作后一直从事软件开发和软件项目管理工作,对计算机语言、计算机体系结构、操作系统都非常熟悉,尤其是精通C和C++编程技术. 目录封面 -19 封底 -18 扉页 -17 版权 -16 前言 -15 目录 -10 第1章使用Visual C++ 2010编程 1 1.1 .NET Framework 1 1.2 CLR 2 1.3 编写C++应用程序 3 1.4 学习Windows编程 4 1.4.1 学习C++ 4 1.4.2 C++标准 5 1.4.3 属性 5 1.4.4 控制台应用程序 5 1.4.5 Windows编程概念 6 1.5 集成开发环境简介 7 1.5.1 编辑器 8 1.5.2 编译器 8 1.5.3 链接器 8 1.5.4 库 8 1.6 使用IDE 8 1.6.1 工具栏选项 9 1.6.2 可停靠的工具栏 10 1.6.3 文档 11 1.6.4 项目和解决方案 11 1.6.5 设置Visual C++ 2010的选项 23 1.6.6 创建和执行Windows应用程序 23 1.6.7 创建Windows Forms应用程序 26 1.7 小结 27 1.8 本章主要内容 28 第2章数据、变量和计算 29 2.1 C++程序结构 29 2.1.1 main()函数 36 2.1.2 程序语句 36 2.1.3 空白 38 2.1.4 语句块 38 2.1.5 自动生成的控制台程序 39 2.2 定义变量 40 2.2.1 命名变量 40 2.2.2 声明变量 41 2.2.3 变量的初始值 42 2.3 基本数据类型 42 2.3.1 整型变量 43 2.3.2 字符数据类型 44 2.3.3 整型修饰符 45 2.3.4 布尔类型 46 2.3.5 浮点类型 46 2.3.6 字面值 47 2.3.7 定义数据类型的同义词 48 2.3.8 具有特定值集的变量 49 2.4 基本的输入/输出操作 50 2.4.1 从键盘输入 50 2.4.2 到命令行的输出 50 2.4.3 格式化输出 51 2.4.4 转义序列 52 2.5 C++中的计算 54 2.5.1 赋值语句 54 2.5.2 算术运算 55 2.5.3 计算余数 59 2.5.4 修改变量 60 2.5.5 增量和减量运算符 60 2.5.6 计算的顺序 63 2.6 类型转换和类型强制转换 64 2.6.1 赋值语句中的类型转换 65 2.6.2 显式类型转换 65 2.6.3 老式的类型强制转换 66 2.7 AUTO关键字 66 2.8 查看类型 67 2.9 按位运算符 67 2.9.1 按位AND运算符 68 2.9.2 按位OR运算符 69 2.9.3 按位EOR运算符 71 2.9.4 按位NOT运算符 71 2.9.5 移位运算符 71 2.10 lvalue和rvalue 73 2.11 了解存储时间和作用域 74 2.11.1 自动变量 74 2.11.2 决定变量声明的位置 76 2.11.3 全局变量 77 2.11.4 静态变量 80 2.12 名称空间 80 2.12.1 声明名称空间 81 2.12.2 多个名称空间 82 2.13 C++/CLI编程 84 2.13.1 C++/CLI特有的基本数据类型 84 2.13.2 命令行上的C++/CLI输出 87 2.13.3 C++/CLI特有的功能—— 格式化输出 88 2.13.4 C++/CLI的键盘输入 91 2.13.5 使用safe_cast 92 2.13.6 C++/CLI枚举 92 2.14 查看C++/CLI类型 96 2.15 小结 97 2.16 练习 97 2.17 本章主要内容 98 第3章判断和循环 101 3.1 比较数据值 101 3.1.1 if语句 102 3.1.2 嵌套的if语句 104 3.1.3 嵌套的if-else语句 107 3.1.4 逻辑运算符和表达式 109 3.1.5 条件运算符 112 3.1.6 switch语句 113 3.1.7 无条件转移 116 3.2 重复执行语句块 117 3.2.1 循环的概念 117 3.2.2 for循环的变体 119 3.2.3 while循环 126 3.2.4 do-while循环 128 3.2.5 嵌套的循环 129 3.3 C++/CLI编程 132 3.4 小结 137 3.5 练习 138 3.6 本章主要内容 138 第4章数组、字符串和指针 139 4.1 处理多个相同类型的数据值 139 4.1.1 数组 140 4.1.2 声明数组 140 4.1.3 初始化数组 143 4.1.4 字符数组和字符串处理 144 4.1.5 多维数组 147 4.2 间接数据访问 150 4.2.1 指针的概念 150 4.2.2 声明指针 150 4.2.3 使用指针 152 4.2.4 初始化指针 152 4.2.5 sizeof操作符 158 4.2.6 常量指针和指向常量的指针 159 4.2.7 指针和数组 161 4.3 动态内存分配 168 4.3.1 堆的别名—— 空闲存储器 168 4.3.2 new和delete操作符 168 4.3.3 为数组动态分配内存 169 4.3.4 多维数组的动态分配 171 4.4 使用引用 172 4.4.1 引用的概念 172 4.4.2 声明并初始化lvalue引用 172 4.4.3 声明并初始化rvalue引用 173 4.5 字符串的本地C++库函数 174 4.5.1 查找以空字符结尾的字符串的长度 174 4.5.2 连接以空字符结尾的字符串 174 4.5.3 复制以空字符结尾的字符串 176 4.5.4 比较以空字符结尾的字符串 177 4.5.5 搜索以空字符结尾的字符串 177 4.6 C++/CLI编程 179 4.6.1 跟踪句柄 180 4.6.2 CLR数组 181 4.6.3 字符串 195 4.6.4 跟踪引用 203 4.6.5 内部指针 204 4.7 小结 206 4.8 练习 206 4.9 本章主要内容 207 第5章程序结构(1) 209 5.1 理解函数 209 5.1.1 需要函数的原因 210 5.1.2 函数的结构 210 5.1.3 使用函数 213 5.2 给函数传递实参 216 5.2.1 按值传递机制 216 5.2.2 给函数传递指针实参 217 5.2.3 给函数传递数组 219 5.2.4 给函数传递引用实参 222 5.2.5 使用const修饰符 224 5.2.6 rvalue引用形参 225 5.2.7 main()函数的实参 227 5.2.8 接受数量不定的函数实参 229 5.3 从函数返回值 231 5.3.1 返回指针 231 5.3.2 返回引用 233 5.3.3 函数中的静态变量 236 5.4 递归函数调用 238 5.5 C++/CLI编程 240 5.5.1 接受数量可变实参的函数 241 5.5.2 main( )的实参 242 5.6 小结 243 5.7 练习 243 5.8 本章主要内容 244 第6章程序结构(2) 245 6.1 函数指针 245 6.1.1 声明函数指针 246 6.1.2 函数指针作为实参 249 6.1.3 函数指针的数组 250 6.2 初始化函数形参 250 6.3 异常 252 6.3.1 抛出异常 253 6.3.2 捕获异常 254 6.3.3 MFC中的异常处理 255 6.4 处理内存分配错误 256 6.5 函数重载 257 6.5.1 函数重载的概念 258 6.5.2 引用类型和重载选择 260 6.5.3 何时重载函数 260 6.6 函数模板 261 6.7 使用decltype操作符 263 6.8 使用函数的示例 265 6.8.1 实现计算器 265 6.8.2 从字符串中删除空格 268 6.8.3 计算表达式的值 268 6.8.4 获得项值 270 6.8.5 分析数 271 6.8.6 整合程序 274 6.8.7 扩展程序 275 6.8.8 提取子字符串 277 6.8.9 运行修改过的程序 279 6.9 C++/CLI编程 279 6.9.1 理解泛型函数 280 6.9.2 CLR版本的计算器程序 285 6.10 小结 290 6.11 练习 291 6.12 本章主要内容 292 第7章自定义数据类型 293 7.1 C++中的结构 293 7.1.1 结构的概念 294 7.1.2 定义结构 294 7.1.3 初始化结构 294 7.1.4 访问结构的成员 295 7.1.5 伴随结构的智能感知帮助 298 7.1.6 RECT结构 299 7.1.7 使用指针处理结构 300 7.2 数据类型、对象、类和实例 301 7.2.1 类的起源 303 7.2.2 类的操作 303 7.2.3 术语 303 7.3 理解类 304 7.3.1 定义类 304 7.3.2 声明类的对象 305 7.3.3 访问类的数据成员 305 7.3.4 类的成员函数 307 7.3.5 成员函数定义的位置 309 7.3.6 内联函数 309 7.4 类构造函数 310 7.4.1 构造函数的概念 311 7.4.2 默认的构造函数 312 7.4.3 在类定义中指定默认的形参值 314 7.4.4 在构造函数中使用初始化列表 316 7.4.5 声明显式的构造函数 317 7.5 类的私有成员 318 7.5.1 访问私有类成员 320 7.5.2 类的友元函数 321 7.5.3 默认复制构造函数 323 7.6 this指针 325 7.7 类的const对象 327 7.7.1 类的const成员函数 327 7.7.2 类外部的成员函数定义 328 7.8 类对象的数组 329 7.9 类的静态成员 331 7.9.1 类的静态数据成员 331 7.9.2 类的静态函数成员 334 7.10 类对象的指针和引用 334 7.10.1 类对象的指针 334 7.10.2 类对象的引用 337 7.11 C++/CLI编程 338 7.11.1 定义值类类型 339 7.11.2 定义引用类类型 344 7.11.3 定义引用类类型的复制构造函数 346 7.11.4 类属性 346 7.11.5 initonly字段 358 7.11.6 静态构造函数 360 7.12 小结 360 7.13 练习 360 7.14 本章主要内容 361 第8章深入理解类 363 8.1 类析构函数 363 8.1.1 析构函数的概念 363 8.1.2 默认的析构函数 364 8.1.3 析构函数与动态内存分配 366 8.2 实现复制构造函数 369 8.3 在变量之间共享内存 370 8.3.1 定义联合 371 8.3.2 匿名联合 372 8.3.3 类和结构中的联合 372 8.4 运算符重载 373 8.4.1 实现重载的运算符 373 8.4.2 实现对比较运算符的完全支持 376 8.4.3 重载赋值运算符 379 8.4.4 重载加法运算符 384 8.4.5 重载递增和递减运算符 387 8.4.6 重载函数调用操作符 388 8.5 对象复制问题 389 8.5.1 避免不必要的复制操作 389 8.5.2 应用rvalue引用形参 392 8.5.3 命名的对象是lvalue 394 8.6 类模板 399 8.6.1 定义类模板 400 8.6.2 根据类模板创建对象 402 8.6.3 使用有多个形参的类模板 405 8.6.4 函数对象模板 406 8.7 使用类 407 8.7.1 类接口的概念 407 8.7.2 定义问题 407 8.7.3 实现CBox类 408 8.8 组织程序代码 425 8.9 字符串的本地C++库类 427 8.9.1 创建字符串对象 427 8.9.2 连接字符串 429 8.9.3 访问与修改字符串 432 8.9.4 比较字符串 436 8.9.5 搜索字符串 439 8.10 C++/CLI编程 447 8.10.1 在值类中重载运算符 447 8.10.2 重载递增和递减运算符 452 8.10.3 在引用类中重载运算符 453 8.10.4 实现引用类型的赋值运算符 455 8.11 小结 456 8.12 练习 456 8.13 本章主要内容 457 第9章类继承和虚函数 459 9.1 面向对象编程的基本思想 459 9.2 类的继承 460 9.2.1 基类的概念 461 9.2.2 基类的派生类 461 9.3 继承机制下的访问控制 464 9.3.1 派生类中构造函数的操作 467 9.3.2 声明类的保护成员 470 9.3.3 继承类成员的访问级别 473 9.4 派生类中的复制构造函数 474 9.5 友元类成员 477 9.5.1 友元类 479 9.5.2 对类友元关系的限制 479 9.6 虚函数 479 9.6.1 虚函数的概念 481 9.6.2 使用指向类对象的指针 483 9.6.3 使用引用处理虚函数 485 9.6.4 纯虚函数 486 9.6.5 抽象类 487 9.6.6 间接基类 489 9.6.7 虚析构函数 491 9.7 类类型之间的强制转换 494 9.8 嵌套类 495 9.9 C++/CLI编程 498 9.9.1 装箱与拆箱 499 9.9.2 C++/CLI类的继承 499 9.9.3 接口类 505 9.9.4 定义接口类 505 9.9.5 类和程序集 509 9.9.6 被指定为new的函数 513 9.9.7 委托和事件 514 9.9.8 引用类的析构函数和终结器 525 9.9.9 泛型类 527 9.10 小结 536 9.11 练习 536 9.12 本章主要内容 539 第10章标准模板库 541 10.1 标准模板库的定义 541 10.1.1 容器 542 10.1.2 容器适配器 542 10.1.3 迭代器 543 10.1.4 算法 544 10.1.5 STL中的函数对象 545 10.1.6 函数适配器 545 10.2 STL容器范围 545 10.3 序列容器 545 10.3.1 创建矢量容器 546 10.3.2 矢量容器的容量和大小 549 10.3.3 访问矢量中的元素 553 10.3.4 在矢量中插入和删除元素 553 10.3.5 在矢量中存储类对象 555 10.3.6 排序矢量元素 559 10.3.7 排序矢量中的指针 560 10.3.8 双端队列容器 562 10.3.9 使用列表容器 565 10.3.10 使用其他序列容器 574 10.4 关联容器 588 10.4.1 使用映射容器 589 10.4.2 使用多重映射容器 600 10.5 关于迭代器的更多内容 600 10.5.1 使用输入流迭代器 601 10.5.2 使用插入迭代器 604 10.5.3 使用输出流迭代器 605 10.6 关于函数对象的更多内容 607 10.7 关于算法的更多内容 608 10.7.1 fill() 608 10.7.2 replace() 609 10.7.3 find() 609 10.7.4 transform() 610 10.8 lambda表达式 611 10.8.1 capture子句 612 10.8.2 捕获特定的变量 613 10.8.3 模板和lambda表达式 613 10.8.4 包装lambda表达式 617 10.9 C++/CLI程序的STL 618 10.9.1 STL/CLR容器 619 10.9.2 使用序列容器 619 10.9.3 使用关联容器 627 10.10 C++/CLI中的lambda表达式 633 10.11 小结 633 10.12 练习 633 10.13 本章主要内容 634 第11章调试技术 635 11.1 理解调试 635 11.1.1 程序故障 636 11.1.2 常见故障 637 11.2 基本的调试操作 638 11.2.1 设置断点 639 11.2.2 设置跟踪点 641 11.2.3 启动调试模式 641 11.2.4 修改变量的值 645 11.3 添加调试代码 645 11.3.1 使用断言 645 11.3.2 添加自己的调试代码 647 11.4 调试程序 652 11.4.1 调用栈 652 11.4.2 单步执行到出错位置 653 11.5 测试扩展的类 656 11.6 调试动态内存 659 11.6.1 检查空闲存储器的函数 660 11.6.2 控制空闲存储器的调试操作 661 11.6.3 空闲存储器的调试输出 662 11.7 调试C++/CLI程序 668 11.7.1 使用调试类Debug和跟踪类Trace 668 11.7.2 在Windows Forms应用程序中获得跟踪输出 676 11.8 小结 677 11.9 本章主要内容 677 第12章 Windows编程的概念 679 12.1 Windows编程基础 679 12.1.1 窗口的元素 680 12.1.2 Windows程序与操作系统 681 12.1.3 事件驱动型程序 682 12.1.4 Windows消息 682 12.1.5 Windows API 682 12.1.6 Windows数据类型 683 12.1.7 Windows程序中的符号 684 12.2 Windows程序的结构 685 12.2.1 WinMain()函数 686 12.2.2 消息处理函数 696 12.2.3 简单的Windows程序 700 12.3 Windows程序的组织 701 12.4 MFC 702 12.4.1 MFC表示法 702 12.4.2 MFC程序的组织方式 702 12.5 使用Windows Forms 706 12.6 小结 707 12.7 本章主要内容 707 第13章多核编程 709 13.1 并行处理基本知识 709 13.2 并行模式库 710 13.3 并行处理算法 710 13.3.1 使用parallel_for算法 710 13.3.2 使用parallel_for_each算法 712 13.3.3 使用parallel_invoke算法 714 13.4 真正的并行问题 715 13.5 临界区 728 13.5.1 使用critical_section对象 728 13.5.2 锁定代码节或解除代码节锁定 729 13.6 combinable类模板 731 13.7 任务和任务组 733 13.8 小结 736 13.9 练习 736 13.10 本章主要内容 736 第14章使用MFC编写Windows程序 739 14.1 MFC的文档/视图概念 739 14.1.1 文档的概念 739 14.1.2 文档界面 740 14.1.3 视图的概念 740 14.1.4 链接文档和视图 741 14.1.5 应用程序和MFC 742 14.2 创建MFC应用程序 743 14.2.1 创建SDI应用程序 745 14.2.2 MFC Application Wizard的输出 748 14.2.3 创建MDI应用程序 757 14.3 小结 760 14.4 练习 760 14.5 本章主要内容 760 第15章处理菜单和工具栏 763 15.1 与Windows进行通信 763 15.1.1 了解消息映射 764 15.1.2 消息类别 767 15.1.3 处理程序中的消息 767 15.2 扩展Sketcher程序 768 15.3 菜单的元素 769 15.4 为菜单消息添加处理程序 771 15.4.1 选择处理菜单消息的类 773 15.4.2 创建菜单消息函数 773 15.4.3 编写菜单消息函数的代码 775 15.4.4 添加更新用户界面的消息处理程序 778 15.5 添加工具栏按钮 781 15.5.1 编辑工具栏按钮的属性 782 15.5.2 练习使用工具栏按钮 783 15.5.3 添加工具提示 784 15.6 C++/CLI程序中的菜单和工具栏 785 15.6.1 理解Windows Forms 785 15.6.2 理解Windows Forms应用程序 786 15.6.3 在CLR Sketcher中添加菜单 788 15.6.4 添加菜单项的事件处理程序 790 15.6.5 实现事件处理程序 791 15.6.6 设置菜单项复选 792 15.6.7 添加工具栏 793 15.7 小结 797 15.8 练习 797 15.9 本章主要内容 797 第16章在窗口中绘图 799 16.1 窗口绘图的基础知识 799 16.1.1 窗口工作区 800 16.1.2 Windows图形设备界面 800 16.2 Visual C++中的绘图机制 802 16.2.1 应用程序中的视图类 802 16.2.2 CDC类 803 16.3 实际绘制图形 811 16.4 对鼠标进行编程 813 16.4.1 鼠标发出的消息 813 16.4.2 鼠标消息处理程序 814 16.4.3 使用鼠标绘图 816 16.5 练习使用Sketcher程序 837 16.5.1 运行示例 838 16.5.2 捕获鼠标消息 838 16.6 在CLR中绘图 840 16.6.1 在窗体上绘图 840 16.6.2 添加鼠标事件处理程序 840 16.6.3 定义C++/CLI元素类 842 16.6.4 实现MouseMove事件处理程序 850 16.6.5 实现MouseUp事件处理程序 851 16.6.6 实现窗体的Paint事件处理程序 851 16.7 小结 852 16.8 练习 852 16.9 本章主要内容 853 第17章创建文档和改进视图 855 17.1 创建草图文档 855 17.2 改进视图 859 17.2.1 更新多个视图 859 17.2.2 滚动视图 861 17.2.3 使用MM_LOENGLISH映射模式 865 17.3 删除和移动形状 866 17.4 实现上下文菜单 866 17.4.1 关联菜单和类 867 17.4.2 练习弹出菜单 870 17.4.3 突出显示元素 870 17.4.4 处理菜单消息 874 17.5 处理屏蔽的元素 881 17.6 扩展CLR Sketcher 882 17.6.1 坐标系统转换 882 17.6.2 定义草图类 885 17.6.3 在Paint事件处理程序中绘制草图 886 17.6.4 实现元素的突出显示 887 17.6.5 创建上下文菜单 891 17.7 小结 897 17.8 练习 897 17.9 本章主要内容 898 第18章使用对话框和控件 899 18.1 理解对话框 899 18.2 理解控件 900 18.3 创建对话框资源 900 18.3.1 给对话框添加控件 901 18.3.2 测试对话框 902 18.4 对话框的编程 902 18.4.1 添加对话框类 902 18.4.2 模态和非模态对话框 903 18.4.3 显示对话框 903 18.5 支持对话框控件 906 18.5.1 初始化控件 906 18.5.2 处理单选按钮消息 907 18.6 完成对话框的操作 908 18.6.1 给文档添加线宽 908 18.6.2 给元素添加线宽 909 18.6.3 在视图中创建元素 910 18.6.4 练习使用对话框 910 18.7 使用微调按钮控件 911 18.7.1 添加Scale菜单项和工具栏按钮 911 18.7.2 创建微调按钮 911 18.7.3 生成比例对话框类 913 18.7.4 显示微调按钮 915 18.8 使用缩放比例 916 18.8.1 可缩放的映射模式 916 18.8.2 设置文档的大小 917 18.8.3 设置映射模式 918 18.8.4 同时实现滚动与缩放 919 18.9 使用CTaskDialog类 921 18.9.1 显示任务对话框 921 18.9.2 创建CTaskDialog对象 923 18.10 使用状态栏 925 18.11 使用列表框 929 18.11.1 删除比例对话框 929 18.11.2 创建列表框控件 929 18.12 使用编辑框控件 931 18.12.1 创建编辑框资源 931 18.12.2 创建对话框类 933 18.12.3 添加Text菜单项 934 18.12.4 定义文本元素 935 18.12.5 实现CText类 935 18.13 CLR Sketcher中的对话框和控件 940 18.13.1 添加对话框 940 18.13.2 创建文本元素 946 18.14 小结 953 18.15 练习 953 18.16 本章主要内容 953 第19章存储和打印文档 955 19.1 了解序列化 955 19.2 序列化文档 956 19.2.1 文档类定义中的序列化 956 19.2.2 文档类实现中的序列化 957 19.2.3 基于CObject的类的功能 959 19.2.4 序列化的工作方式 960 19.2.5 如何实现类的序列化 961 19.3 应用序列化 961 19.3.1 记录文档修改 962 19.3.2 序列化文档 963 19.3.3 序列化元素类 965 19.4 练习序列化 968 19.5 打印文档 969 19.6 实现多页打印 972 19.6.1 获取文档的总尺寸 973 19.6.2 存储打印数据 973 19.6.3 准备打印 974 19.6.4 打印后的清除 976 19.6.5 准备设备上下文 976 19.6.6 打印文档 977 19.6.7 获得文档的打印输出 980 19.7 CLR Sketcher中的序列化和打印 981 19.7.1 了解二进制序列化 981 19.7.2 序列化草图 985 19.7.3 打印草图 995 19.8 小结 996 19.9 练习 996 19.10 本章主要内容 997 第20章编写自己的DLL 999 20.1 了解DLL 999 20.1.1 DLL的工作方式 1000 20.1.2 DLL的内容 1003 20.1.3 DLL变体 1003 20.2 决定放入DLL的内容 1004 20.3 编写DLL 1005 20.4 小结 1011 20.5 练习 1011 20.6 本章主要内容 1011 前言　　欢迎使用本书。通过学习本书，您可以使用Microsoft公司最新的应用程序开发系统，成为优秀的C++程序员。本书旨在讲述C++程序设计语言，然后讲述如何运用C++语言开发自己的Windows应用程序。在此过程中，读者将了解这一最新Visual C++版本所提供的很多激动人心的新功能，包括如何在自己的应用程序中充分利用多核处理器。　　0.1 使用C++语言编程　　Visual C++ 2010支持两种截然不同但又紧密相关的C++语言，即ISO/IEC标准C++(本书称其为本地C++)和C++/CLI。虽然很多专业开发人员选用本地C++，尤其是当性能是需要考虑的主要因素时，但是C++/CLI和Windows Forms应用程序带来的开发速度和简易性使得C++/CLI也成了基本的语言。因此，本书将深入讨论这两种版本的C++语言。　　Visual C++ 2010完全支持原来的ISO/IEC标准C++语言，同时还支持即将发布的ISO/IEC标准C++提供的一些功能强大的新特性。因此，本书不仅涵盖ISO/IEC标准C++的原有功能，同时还会介绍新语言特性。　　Visual C++ 2010也支持C++/CLI，它是Microsoft公司作为本地C++的扩展而开发的C++版本。C++/CLI背后的思想是向本地C++添加一些特性，从而能够开发以.NET支持的虚拟机环境为目标的应用程序。这就将C++添加到能使用.NET Framework的其他语言(例如，BASIC和C#)中。C++/CLI语言目前是一个ECMA标准，同时也符合定义.NET虚拟机环境的CLI标准。　　Visual C++ 2010的这两种C++版本互为补充，各自完成不同的任务。ISO/IEC C++用于开发在本地计算机上运行的高性能应用程序，而C++/CLI专门为.NET Framework开发应用程序。掌握了使用这两种C++版本开发应用程序的基础知识之后，就能够充分利用Visual C++ 2010。　　0.2 开发Windows应用程序　　充分理解C++之后，就可以着手开发Windows应用程序。Microsoft基本类(Microsoft Foundation Classes，MFC)封装了Windows API，提供了全面而易于使用的功能，从而能够使用本地C++开发高性能的Windows应用程序。　　当编写本地C++程序时，可以从自动生成的代码中获得大量帮助，但仍然需要亲自编写大量C++代码。我们不仅需要对面向对象编程(OOP)技术有扎实的理解，而且需要充分了解Windows编程所涉及的各个方面。本书会介绍所有这些知识点。　　C++/CLI虽然针对.NET Framework开发，但同时也是Windows Forms应用程序开发的载体。开发Windows Forms应用程序时，在不用编写一行代码的情况下，即使不能创建应用程序交互所需的用户界面的所有元素，也可以创建其中的很多元素。当然，仍然需要定制Windows Forms应用程序，才能完成相应的任务，但开发时间与使用本地C++创建应用程序相比只占一小部分。当给Windows Forms应用程序添加定制代码时，即使这部分代码只占到代码总量的很小比例，也仍然要求我们深入理解C++/CLI语言，才能做到游刃有余。本书旨在介绍这些知识。　　0.3 高级库功能　　并行模式库(Parallel Patterns Library，PPL)是Visual C++ 2010增加的一个令人激动的新功能，通过此功能，我们可以轻松编写使用多处理器的程序。在过去，为多处理器编程并非易事，但有了PPL，这就确实变得很容易了。本书将介绍PPL的各种使用方式，从而加快计算密集型应用程序的执行速度。　　0.4 本书读者对象　　本书针对任何想要学习如何使用Visual C++ 2010编写在Microsoft Windows操作系统下运行的C++应用程序的读者。阅读本书不需要预先具备任何特定编程语言的知识。如果属于下列4种情形之一，您就适合学习本教程：　　·属于编程新手，十分渴望投入编程世界，并最终掌握C++。要取得成功，您至少需要对计算机的工作原理有大体的理解——包括内存的组织方式以及数据和指令的存储方式。　　·具备一些其他语言的编程经验，如BASIC；渴望学习C++，并想提升实际的Microsoft Windows编程技能。　　·有一些使用C语言或C++语言的经验，但使用环境不是Microsoft Windows；希望使用最新的工具和技术，扩展在Windows环境下编程的技能。　　·有一些C++知识，并希望扩展C++技能，成为会使用C++/CLI的编程人员。　　0.5 本书主要内容　　本书实质上涵盖了两大主题：C++编程语言以及如何使用MFC或.NET Framework编写Windows应用程序。在开发完全成熟的Windows应用程序之前，需要具备相当水平的C++知识，因此，首先学习这本C++教程。 .　　本书的第一部分通过可运行于两种C++语言版本上的一个详细的循序渐进式教程，讲授了使用Visual C++ 2010支持的两种C++语言技术编写C++程序的基础知识。您将了解本地ISO/IEC C++语言的语法和用法，并通过一系列范围广泛的可工作示例，获得实际运用它的经验和信心。本书也提供了一些练习，可以检验所学的知识，并且可以下载练习题答案。而C++/CLI作为本地C++的扩展来学习，这仍然是通过一些可运行的示例来说明每一个特性的工作原理。　　当然，本语言教程也介绍和说明了C++标准库功能的用法，因为开发程序时极有可能使用它们。随着深入地学习C++语言，您的标准库知识会不断增加。还将学习标准模板库(Standard Template Library，STL)以两种形式——即本地C++版本和C++/CLI版本——提供的强大工具。另外，本书还用一章的篇幅专门讲述新增的并行模式库(PPL)功能，从而能够利用PC的多核处理功能来开发计算密集型应用程序。　　对C++的运用有信心之后，就可以继续学习Windows编程了。通过创建超过2000行代码的大型可运行的应用程序，学习如何使用MFC来开发本地Windows应用程序。开发此应用程序贯穿多章内容，使用到了MFC提供的一系列用户界面功能。为学习如何使用C++/CLI编写Windows程序，相应地开发了一个与本地C++应用程序具有相似用户界面特性的Windows Forms应用程序。　　0.6 本书结构　　本书内容的结构安排如下：　　·第1章介绍使用C++编写本地应用程序和.NET Framework应用程序所需要理解的基本概念，以及在Visual C++ 2010开发环境中体现的主要思想，还叙述了如何使用Visual C++ 2010的功能来创建本书其余部分要学习的各种C++应用程序。　　·第2~9章讲授两种C++语言版本。第2~9章内容的组织方式都相似：各章的前半部分讨论本地C++语言的元素，后半部分讨论如何在C++/CLI中提供相同的功能。　　·第10章介绍如何使用标准模板库(Standard Template Library，STL)。STL是一组功能强大且全面的工具，用来组织和操作本地C++程序中的数据。由于STL是独立于应用程序的，因此可以在上下文中大量应用它。第10章还介绍了Visual C++ 2010新增的STL/CLR。它是C++/CLI应用程序的STL版本。　　·第11章介绍了在C++程序中查找错误的技术。涵盖了调试程序的一般原则，以及Visual C++ 2010提供的基本特性，这些特性可以帮助我们查找代码中的错误。　　·第12章讨论Microsoft Windows应用程序的组织方式，并描述和展示了在所有Windows应用程序中都存在的基本元素。本章解释了以本地C++语言编写的、使用Windows API和MFC的Windows应用程序示例，还给出了一个使用C++/CLI语言编写的Windows Forms应用程序的基础示例。　　·第13章介绍了如何在PC有多核处理器的情况下编写程序以使用多个处理器。通过一些完整的工作示例展示了并行处理的基本技术，这些示例Windows API应用程序是计算密集型程序。　　·第14~19章讲述Windows编程。详细描述了如何使用MFC提供的构建GUI的功能编写本地C++ Windows应用程序以及如何在C++/CLI Windows应用程序中使用.NET Framework。我们将学习如何创建并使用通用控件来构建应用程序的图形用户界面，还将学习如何处理因用户与程序的交互作用而产生的事件。除了学习构建GUI的技术以外，还将从开发该应用程序的过程中学到如何打印文档，以及如何在磁盘上保存应用程序数据。　　·第20章讲述为使用MFC创建自己的库而需要知道的基本知识。我们将了解可以创建的不同种类的库，还将开发能够与前6章开发的应用程序协同工作的示例。　　本书各章内容都包括许多工作示例，通过这些示例阐明所讨论的编程技术。每章结束时都总结了该章所讲述的要点，大多数章节都在最后给出了一组练习，您可以应用所学的技术来试着解答这些练习。练习的答案连同书中的所有代码都可以从http://www.wrox.com和http://www.tupwk.com.cn/ downpage下载。关于C++语言教程使用的示例都是使用简单的命令行输入和输出的控制台程序。这种方法使我们能够在不陷入复杂的Windows GUI编程的情况下，学习C++的各种功能。实际上，只有在透彻地理解编程语言之后，才能进行Windows 编程。　　如果希望使学习过程尽可能简单，或者如果您是程序设计初学者，那么最初可以只学习本地C++编程语言。讲授C++语言的各章(第2~9章)都是首先讨论本地C++功能的特定方面，然后再讨论C++/CLI在相同的上下文中引入的新功能。以这种方式组织各章内容的原因在于，C++/CLI是作为ISO/IEC标准语言的扩展定义的，对C++/CLI的理解是以对ISO/IEC C++的理解为基础的。因此，您可以只阅读各章中的本地C++部分，而忽略后面的C++/CLI部分。然后可以继续使用本地C++开发Windows应用程序，而免去记住两种语言版本的苦恼。在熟悉了ISO/IEC C++之后，您可以回头重新学习C++/CLI。当然，如果您已经有一些编程经验，也可以逐章进行学习，从而同步增加这两种C++语言版本的知识。　　0.7 使用本书的前提　　为了充分地使用本书，需要可支持MFC的某个Visual C++ 2010(或Visual Studio 2010)版本。需要注意的是，免费的Visual C++ 2010 Express Edition版本是不行的。因为此版本只提供C++编译器以及对基本Windows API的访问，并没有提供MFC库。因此，Visual C++ 2010(或Visual Studio 2010)的任何付费版本都能够编译并执行本书的所有示例。　　0.8 源代码　　读者在阅读本书提供的代码时，既可以亲自输入所有代码，也可以使用随书提供的代码文件。本书所有代码均可以从http://www.wrox.com/或www.tupwk.com.cn/downpage网站下载。进入该网站后，读者可以根据本书的书名查找本书(既可以使用搜索框，也可以使用书名列表进行查找)，然后单击本书详细内容页面上提供的Download Code链接，就可以下载本书提供的所有代码。　　注意：　　由于许多书籍名称与本书类似，读者也可以通过ISBN进行查找，本书的ISBN为：978-0-470-50088-0。　　另外，读者可以从前面提到的CodePlex网站下载本书或其他Wrox书籍的代码，也可以从Wrox的代码下载页面http://www.wrox.com/dynamic/books/download.aspx和http://www. tupwk.com.cn/downpage下载本书或其他Wrox书籍的代码。　　源代码下载成功后，读者用任一解压工具将其解压即可。　　0.9 勘误表　　为了避免本书文字和代码中存在错误，我们已经竭尽全力。然而，世界上并不存在完美无缺的事物，所以本书可能仍然存在错误。如果读者在我们编写的某本书籍中发现了诸如拼写错误或代码缺陷等问题，那么请告诉我们，我们对此表示感谢。利用勘误表反馈错误信息，可以为其他读者节省大量时间，同时，我们也能够受益于读者的帮助，这样有助于我们编写出质量更高的专业著作。　　如果读者需要参考本书的勘误表，请在网站http://www.wrox.com中用搜索框或书名列表查找本书书名。然后，在本书的详细内容页面上，单击Book Errata链接。在随后显示的页面中，读者可以看到与本书相关的所有勘误信息，这些信息是由读者提交、并由Wrox的编辑们加上的。通过访问http://www.wrox.com/misc-pages/booklist.shtml，读者还可以看到Wrox出版的所有书籍的勘误表。　　如果读者没有在Book Errata页面上找到自己发现的错误，那么请转到页面http://www. wrox.com/contact/techsupport.shtml，针对您所发现的每一项错误填写表格，并将表格发给我们，我们将对表格内容进行认真审查，如果确实是我们书中的错误，我们将在该书的Book Errata页面上标明该错误信息，并在该书的后续版本中改正。　　0.10 关于p2p.wrox.com网站　　如果读者希望能够与作者进行讨论，或希望能够参与到读者的共同讨论中，那么请加入p2p.wrox.com论坛。该论坛是一个基于Web的系统，读者可以在论坛发表与Wrox出版的书籍及相关技术的信息，并与其他读者和技术用户进行讨论。论坛提供了订阅功能，可以将与读者所选定主题相关的新帖子定期发送到读者的电子邮箱。Wrox的作者、编辑、业界专家，以及其他读者都会参与论坛中的讨论。　　读者可以在http://p2p.wrox.com参与多个论坛的讨论，这些论坛不仅能够帮助读者更好地理解本书，还有助于读者更好地开发应用程序。如果读者希望加入论坛，那么请按照以下步骤执行：　　(1) 进入http://p2p.wrox.com页面，单击Register链接。　　(2) 阅读使用条款，然后单击Agree按钮。　　(3) 填写必要的信息及可选信息，然后单击Submit按钮。　　(4) 随后读者会收到一封电子邮件，邮件中说明了如何验证账户并完成整个加入过程。　　读者无须加入P2P论坛即可阅读论坛消息，但如果需要发表主题或发表回复，那么必须加入论坛。　　成功加入论坛后，读者就可以发表新主题了。此时，读者还可以回复其他用户发表的主题。读者在任何时间都可以阅读论坛信息，如果需要论坛将新的信息发送到自己的电子邮箱，那么可以单击论坛列表中论坛名称旁的Subscribe to this Forum图标完成这项功能设置。　　如果读者需要获得更多与Wrox P2P相关的信息，请阅读P2P FAQs，这样可以获得大量与P2P和Wrox出版的书籍相关的具体信息。阅读FAQs时，请单击P2P页面上的FAQs链接。　　

摘自：http://mbstudio.spaces.live.com/blog/cns!C898C3C40396DC11!955.entry 2007/1/30 oSIP协议栈(及eXoSIP,Ortp等)使用入门（原创更新中）（CopyLeft by Meineson | www.mbstudio.cn，原创文章，欢迎转载，但请保留出处说明！）本文档最新版本及文中提到的相关源码及VC6工程文件请在本站找，嘿嘿~~ （首页的SkyDriver公开文件夹中，可能需要用代理才能正常访问该空间——空间绝对稳定，不会丢失文件！） (最近工作重心不在SIP开发，SO本文档也没有机会更新，有技术问题也请尽量咨询他人，本人不一定能及时回复。) 　　一直没空仔细研究下oSIP，最近看到其版本已经到了3.x版本，看到网上的许多帮助说明手册都过于陈旧，且很多文档内容有点误人子弟的嫌疑～～　　Ｌｉｎｕｘ下ｏＳＩＰ的编译使用应该是很简单的，其Ｉｎｓｔａｌｌ说明文档里也介绍的比较清楚，本文主要就ｏＳＩＰ在Ｗｉｎｄｏｗｓ平台下ＶＣ６．０开发环境下的使用作出描述。　　虽然ｏＳＩＰ的开发人员也说明了，ｏＳＩＰ只使用了标准Ｃ开发库，但许多人在Ｗｉｎｄｏｗｓ下使用ｏＳＩＰ时，第一步就被卡住了，得不到ｏＳＩＰ的ＬＩＢ库和ＤＬＬ库，也就没有办法将ｏＳＩＰ使用到自己的程序中去，所以第一步，我们将学习如何得到ｏＳＩＰ的静态和动态链接库，以便我们自己的程序能够使用它们来成功编译和执行我们的程序。第一阶段：－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－　　先创建新工程，网上许多文档都介绍创建一个Ｗｉｎ３２动态链接库工程，我们这里也一样，创建一个空白的工程保存。　　同样，将ｏＳＩＰ２版本３．０．１ src目录下的Ｏｓｉｐｐａｒｓｅｒ２目录下的所有文件都拷到我们刚创建的工程的根目录下，在ＶＣ６上操作：Ｐｒｏｊｅｃｔ－Ａｄｄ　Ｔｏ　Ｐｒｏｊｅｃｔ－Ｆｉｌｅｓ　　将所有的源程序和头文件都加入到工程内，保存工程。　　这时，我们可以尝试编译一下工程，你会得到许多错误提示信息，其内容无非是找不到osipparser2/xxxxx.h头文件之类。　　处理：在Ｌｉｎｕｘ下，我们一般是将头文件，ｌｉｂ库都拷到/usr/inclue;/usr/lib之类的目录下，ｃ源程序里直接写#include 时，能直接去找到它们，在ＶＣ里，同样的，最简单的方法就是将ｏＳＩＰ２源码包中的Ｉｎｃｌｕｄｅ目录下的 osipparser2目录直接拷到我们的Ｗｉｎｄｏｗｓ下默认包含目录即可，这个目录在ＶＣ６的Ｔｏｏｌ－Ｏｐｔｉｏｎｓ－Ｄｉｒｅｃｔｏｒｉｅｓ里设置，（当然，如果你知道这一步，也可以不用拷贝文件，直接在这里把ｏＳＩＰ源码包所在目录加进来就可以了），默认如果装在Ｃ盘，目录则为 C:\Program Files\Microsoft Visual Studio\VC98\Include。　　这时，我们再次编译我们的工程，顺利编译，生成osipparser2.dll，这时，网上很多文档里可能直接就说，这一步也会生成libs目录，里面里osipparser2.lib文件，但我们这里没有生成：）　　最简单的方法，不用深究，直接再创建一个工程，同上述创建动态链接库方法，创建一个Ｗｉｎ３２静态链接库工程，直接编译，即可得到osipparser2.lib。－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－　　上面，我们得到了Ｏｓｉｐ的解析器开发库，下面再编译完整的Ｏｓｉｐ协议栈开发库，同样照上述方法，分别创建动态链接库工程和静态链接库工程，只是要拷的文件换成src下的osip目录下文件和include下的osip目录，得到osip2.dll和osip2.lib。　　在编译osip2.dll这一步可能会再次得到错误，内容含义是找不到链接库，所以，我们要把前面编译得到的osipparser2.lib也拷到osip工程目录下，并在ＶＣ６中操作：　　Ｐｒｏｊｅｃｔ－Ｓｅｔｔｉｎｇ－Ｌｉｎｋ中的Ｏｂｊｅｃｔ／Ｌｉｂｒａｒｙ　Ｍｏｄｕｌｅｓ： kernel32.lib user32.lib ... xxx.lib之类的内容最后增加: osipparser2.lib 　　保存工程后再次编译，即可成功编译osip2.dll。－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－　　至此，我们得到了完整的ｏＳＩＰ开发库，使用时，只需在我们的程序里包含ｏＳＩＰ的头文件，工程的链接参数里增加osipparser2.lib和osip2.lib即可。－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－　　下面我们验证一下我们得到的开发库，并大概了解一下ＯＳＩＰ的语法规范。　　在VC里创建win32控制台程序工程，将libosip源码包的SRC目录下的Test目录内的C源程序随便拷一个到工程时，直接编译（工程设置里照前文方法在link选项里增加osip2.lib,osipparser2.lib引用我们之前成功编译得到的静态库文件）就可以运行（带参数运行，参数一般为一个文本文件，同样从Test目录的res目录里拷一个与源文件同名的纯文本文件到工程目录下即可）。　　该目录下的若干文件基本上是测试了Osip的一些基本功能函数，例如URI解析之类，可以大概了解一下oSIP的语法规范和调用方法，同时也能校验一下之前编译的OSIP开发库能否正常使用，成功完成本项工作后，可以进入下一步具体的oSIP的使用学习了。－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－　　由于ｏＳＩＰ是比较底层的ＳＩＰ协议栈实现，新手较难上手，而官方的示例大都是一些伪代码，需要有实际的例子程序参考学习，而最好的例子就是同样官方发布的ｏＳＩＰ的扩展开发库exosip２，使用ｅｘｏＳＩＰ可以很方便地快速创建一个完整的ＳＩＰ程序（只针对性地适用于SIP终端开发用，所以我们这里只是用它快速开发一个SIP终端，用来更方便地学习oSIP，要想真正掌握SIP的开发，需要掌握oSIP并熟读RFC文档才行，exoSIP不是我们的最终学习目的），通过成功编译运行一个自己动手开发出的程序，再由浅入深应该是初学都最好的学习方法通过对使用exosip开发库的使用创建自己的ＳＩＰ程序，熟悉后再一个函数一个函数地深入学习exosip提供的接口函数，就可以深入理解osip 了，达到间接学习ｏＳＩＰ的目的，同时也能从eXoSIP中学习到正确使用ｏＳＩＰ的良好的编程风格和语法格式。　　而要成功编译ＥｘｏＳＩＰ，似乎许多人被难住了，直接在ＸＰ－ｓｐ２上，用ＶＣ６，虽然你使用了ｅＸｏＳＩＰ推荐的winsock2.h，但是会得到一个 sockaddr_storage结构不能识别的错误，因为vc6自带的开发库太古董了，需要升级系统的Ｐｌａｔｆｏｒｍ　ＳＤＫ，下载地址如下： http://www.microsoft.com/msdownl ... PSP2FULLInstall.htm（ＶＣ６的支持已经停止，这是ＶＣ６能使用的最新ＳＤＫ）　　成功安装后编译前需加OSIP_MT宏，以启用线程库，否则在程序中使用eXoSIP库时会出错，而编译时也会得到许多函数未定义的Warning提示，编译得到exosip2.lib供我们使用，当然，在此之前需要成功编译了osip2和osipparser2，而在之后的实际使用时，发现ｏＳＩＰ也需要增加ＯＳＩＰ＿ＭＴ宏，否则ＯＳＩＰ＿ＭＴ调用ｏＳＩＰ的线程库时会出错，所以我们需要重新编译ｏＳＩＰ了：），因为ｅＸｏｓｉｐ是基于ｏＳＩＰ的（同上方式创建静态和动态链接库工程，并需在Ｌｉｎｋ中手工添加ｏＳＩＰ和ｏＳＩＰｐａｒｓｅｒ的lib库）。－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－　　创建新工程，可以是任意工程，我们从最简单的Ｗｉｎ３２控制台程序开始，为了成功使用ｏＳＩＰ，我们需要引用相关库，调用相关头文件，经过多次试验，发现需要引用如下的库： exosip2.lib osip2.lib osipparser2.lib WSock32.Lib IPHlpApi.Lib WS2_32.Lib Dnsapi.lib 　　其中，除了我们上面编译得到的三个oSIP库外，其它库都是系统库，其中有一些是新安装的Ｐｌａｔｆｏｒｍ　ＳＤＫ所新提供的。　　至此，我们有了一个简单的开发环境了，可以充分利用网上大量的以ｏＳＩＰ为基础的代码片段和官方说明文档开始具体函数功能的测试和使用了：）－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－　　我们先进行一个简单的纯ＳＩＰ信令（不带语音连接建立）的ＵＡＣ的ＳＩＰ终端的程序开发的试验（即一个只能作为主叫不能作为被叫的的ＳＩＰ软电话模型），我们创建一个ＭＦＣ应用程序，对话框模式，照上面的说明，设置工程包含我们上面得到的ｏＳＩＰ的相关开发库及ＳＤＫ的一些开发库，并且由于默认ＬＩＢＣ的冲突，需要排除MSVCRT[D]开发库（其中Ｄ代表Ｄｅｂｕｇ模式下，没有Ｄ表示Ｒｅｌｅａｓｅ模式下），直接使用ｅＸｏｓｉｐ的几个主要函数就可以创建一个基本的ＳＩＰ软电话模型。　　其主要流程为：　　初始化ｅＸｏｓｉｐ库－启动事件监听线程－向ＳＩＰ　Ｐｒｏｘｙ注册－向某ＳＩＰ终端（电话号码）发起呼叫－建立连接－结束连接　　初始化代码： int ret = 0; ret = eXosip_init (); eXosip_set_user_agent("##YouToo0.1"); if(0 != ret) { AfxMessageBox("Couldn't initialize eXosip!\n"); return false; } ret = eXosip_listen_addr (IPPROTO_UDP, NULL, 0, AF_INET, 0); if(0 != ret) { eXosip_quit (); AfxMessageBox("Couldn't initialize transport layer!\n"); return false; } 　　启动事件监听线程： AfxBeginThread(sip_uac,(void *)this); 　　向ＳＩＰ　Ｐｒｏｘｙ注册： eXosip_clear_authentication_info(); eXosip_add_authentication_info(uname, uname, upwd, "md5", NULL); real_send_register(30);　　/* 自定义函数代码请见源码 */ 　　发起呼叫（构建假的ＳＤＰ描述，实际软电话使用它构建ＲＴＰ媒体连接）： osip_message_t *invite = NULL; /* 呼叫发起消息体 */ int i = eXosip_call_build_initial_invite (&invite, dest_call, source_call, NULL, "## YouToo test demo!"); if (i != 0) { AfxMessageBox("Intial INVITE failed!\n"); } char localip[128]; eXosip_guess_localip (AF_INET, localip, 128); snprintf (tmp, 4096, "v=0\r\n" "o=josua 0 0 IN IP4 %s\r\n" "s=conversation\r\n" "c=IN IP4 %s\r\n" "t=0 0\r\n" "m=audio %s RTP/AVP 0 8 101\r\n" "a=rtpmap:0 PCMU/8000\r\n" "a=rtpmap:8 PCMA/8000\r\n" "a=rtpmap:101 telephone-event/8000\r\n" "a=fmtp:101 0-11\r\n", localip, localip, "9900"); osip_message_set_body (invite, tmp, strlen(tmp)); osip_message_set_content_type (invite, "application/sdp"); eXosip_lock (); i = eXosip_call_send_initial_invite (invite); eXosip_unlock (); 　　挂断或取消通话： int ret; ret = eXosip_call_terminate(call_id, dialog_id); if(0 != ret) { AfxMessageBox("hangup/terminate Failed!"); } 　　可以看到非常简单，再借助于ｏＲＴＰ和Ｍｅｄｉａｓｔｒｅａｍｅｒ开发库，来快速为我们的ＳＩＰ软电话增加ＲＴＰ和与系统语音ＡＰＩ接口交互及语音编码功能，即可以快速开发出一个可用的ＳＩＰ软电话，关于ｏＲＴＰ和Ｍｅｄｉａｓｔｒｅａｍｅｒ的相关介绍不是本文重点，将在有空的时候考虑增加相应使用教程，文章前提到的地方可以下载基本可用的完整ＳＩＰ软电话的ＶＣ源码工程文件供参考使用，完全ＣｏｐｙＬｅｆｔ，欢迎转载，但请在转载时注明作者信息，谢谢！第二阶段：－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－　　得到了一个ＳＩＰ软电话模型后，我们可以根据软电话的实际运行表现（结合用Ethereal抓包分析）来进行代码的分析，以达到利用eXoSIP来辅助我们学习ｏＳＩＰ的最终目的（如要快速开发一个可用的ＳＩＰ软电话，请至前面提到的论坛去下载使用ｏＲＴＰ和Ｍｅｄｉａｓｔｒｅａｍｅｒ快速搭建的一个基本完整可用的ＳＩＰ软电话##YouToo 0.1版本的ＶＣ源码工程文件作参考）。　　现在从eXosip的初始化函数开始入手，来分析oSIP的使用，这是第二阶段，第三阶段就是深入学习oSIP的源码了，但大多数情况下应该没有必要了，因为在第二阶段就有部分涉及到第三阶段的工作了，而且ｏＳＩＰ的源码也就大多是一些ＳＩＰ数据的语法解析和状态机的实现，能深入理解了ＳＩＰ协议后，这些只是一种实现方式，没必要完全去接受，而是可以用自己的方式和风格来实现一套，比如，更轻量化更有适用目的性的方式，ｏＳＩＰ则只起参考作用了。　　eXosip_init()是ｅＸｏｓｉｐ的初始化函数，我们来看看它的内部实现: 　　首行是定义的　osip_t *osip，这在oSIP的官方手册里我们看到，所有使用oSIP的程序都要在最开始处声明一个osip_t的指针，并使用 osip_init(&osip)来初始化这个指针，销毁这个资源使用osip_release(osip)即可。　　我们可以在代码中看到很多OSIP_TRACE，这是调试输出宏调用了函数osip_trace，可以用ENABLE_TRACE宏来打开调试以方便我们开发调试。　　其它就是很多的eXosip_t的全局变量eXosip的一些初始化操作，包括最上面的memset (&eXosip, 0, sizeof (eXosip))完全清空和下面的类似eXosip.user_agent = osip_strdup ("eXosip/" EXOSIP_VERSION)的exosip变量的一些初始值设置，其中有一个eXosip.j_stop_ua = 0应该是一个状态机开关，后面可以看到很多代码检测这个变量来决定是否继续流程处理，默认置成了0表示现在exosip的处理流程是就绪的，即ua是 not stop的。　　　　osip_set_application_context (osip, &eXosip)是比较有意思的，它让下面的eXosip_set_callbacks (osip)给osip设置大量的回调函数时，能让osip能访问到eXosip这个全局变量中设置的大量程序运行时交互的信息，相当于我们在ＶＣ下开启一个线程时，给线程传入的一个ｖｏｉｄ指针指向我们的ＭＦＣ应用程序的当前dialog对象实例，可以用void *osip_get_application_context (osip_t * osip)这个函数来取出指针来使用，不过好象exosip中并没有用到它，可能是留给个人自已扩展的吧:) 　　　　还能看到初始化代码前面有一段ＷＩＮ３２平台下的ＳＯＣＫ的初始化代码，可以知道eXosip是用的原生的winsock api函数，也就是我们可能以前学过的用VC和WINAPI写sock程序时(不是ＭＦＣ)，用到的那段ＳＯＣＫ初始代码，还有一段有意思的代码，就是 jpipe()函数，它们返回的是一个管道，一个有２个整型数值的数组（一个进一个出），查看其代码发现，非WIN32平台是直接使用的pipe系统函数，而ＷＩＮ３２下则是用一对ＴＣＰ的本地ＳＯＣＫ连接来模拟的管道，一个ＳＯＣＫ写一个ＳＯＣＫ读，这段代码是比较有参考价值的：） j = 50; while (aport++ && j-- > 0) { 　　raddr.sin_port = htons ((short) aport); 　　if (bind (s, (struct sockaddr *) &raddr, sizeof (raddr)) transactionid)); } 　　即，只是打印一下调试，并没有完整实现什么功能，我们学习时，完全可以用相同的方法，定义一大堆回调函数，并不忙想怎么完全实现，先都是只打印一下调试信息，看具体的应用逻辑根据抓包测试分析和看调试看程序走到了哪一步，调用了哪一个回调，来明白具体回调函数要实现什么用途，再来实现代码就方便多了，当然，如果看透了ＲＦＣ文档，应该从字面就能知道各个回调函数的用途了，这是后话，不是谁都能快速完全看懂ＲＦＣ的，所以我们要参考eXosip：）　　　　我们对其中的重要的回调函数进行逐个的分析：　　－－－－－－－－－－－－－－－－－－－－－－－－－－－　　osip_set_cb_send_message (osip, &cb_snd_message)　ＳＩＰ消息发送回调函数　　这个函数可能是最重要的回调函数之一，消息发送，包括请求消息和回应消息，一般情况下，状态机的状态就是由它控制的，发起一个消息初始化一个状态机，回应一个消息对状态机修改，终结消息发送结束状态机…… 　　看cb_snd_message的函数实现，要以发现，其主要代码是对参数中的要发送的消息osip_message_t * sip进行分析，找出消息要发送的真实char *host,int port的值（这些参数可以省略，但要发送消息肯定需要host和port，所以要从sip中解析），最后根据sip中解析出的传输方式是TCP还是 UDP选择最终进行消息发送处理的函数cb_udp_snd_message，cb_tcp_snd_message处理（它们的参数一致，即本函数只是补全一些省略的参数并对消息进行合法性检查）。　　**毕竟eXosip是一个通用的开发库，它考虑了要支持TCP,UDP,TCPs,IPV4,IPV6，WIN32,*nix,WINCE等等多样化的复杂环境，所以，我们可以略过我们暂时不需要的部分，比如，ＩＰＶ６相关的代码实现等。　　　　由于我们大多数情况下ＳＩＰ是用的ＵＤＰ，所以先来看一下cb_udp_snd_message的实现，它从全局变量exosip中获取可用的 sock，并尽最大能力解析出host和port（？？难道前面的函数还不够解析彻底？？如最终仍无port信息则默认设置为5060），使用 osip_message_to_str (sip, &message, &length)函数将要发送的格式化的ＳＩＰ消息转换成能用ＳＯＣＫ传输的简单数据并发送即完成消息发送，代码中有许多复杂的环境探测和错误控制等等等等，我们可以暂时不用过多关注，可以继续向下，结尾处有一个keeplive相关代码，从代码字面分析，可能是ＳＩＰ的Register消息的自动重发相关代码，可以在后面再细化分析。　　cb_tcp_snd_essage的函数实现要比上文的udp的实现简单很多，主要是环境探测错误控制方面，因为毕竟tcp是稳定连接的，对比一下代码，可以看到主要流程还是将ＳＩＰ消息转换后，发送到从ＳＩＰ消息中解析出的host和port对应的目标。　　　　看完两个函数，可以知道，eXosip需要有两个sock，是一个数组，0是给ＵＤＰ用的，１是给ＴＣＰ用的，要用ＳＯＣＫ当然要初始化，就是下文要介绍的eXosip的网络相关的初始化了，上面的exosip_init可以看成是这个开发库的系统初始化吧：）　　　至些，我们应该知道了ｏＳＩＰ开发的ＳＩＰ应用程序的消息是从哪里发出的吧，对了，就是从这个回调函数里，所谓万事开头难，就象开发ＷＩＮ３２应用程序时，找到了ＷＩＮ３２程序的main函数入口下面的工作就好办了，下面就都是为一些事件消息开发对应的处理函数而已了：）　　osip_set_kill_transaction_callback　事务终结回调函数　　对应ＩＣＴ，ＩＳＴ，ＮＩＣＴ，ＮＩＳＴ客户/服务器注册/非注册事务状态机的终结，主要是使用osip_remove_transaction (eXosip.j_osip, tr)将当前tr事务删除，再加上一系列的清理工作，其中，NICT即客户端的非Ｉｎｖｉｔｅ事务的清理比较复杂一些，要处理的内容也比较多，可以根据实际应用的情况进行有必要的清理工作：）　　cb_transport_error　传输失败处理回调　　对应于上面说到的四种事务状态机，如果它们在处理时失败，则在这时进行统一处理。　　从代码可知，只是在NOTIFY,SUBSCRIBE,OPTION操作失败才进行处理，其它错误可直接忽略。　　osip_set_message_callback　消息发送处理回调　　根据type不同，表示不同的消息发送状态　　OSIP_XXX_AGAIN 重发相关消息　　OSIP_ICT_INVITE_SENT 发起呼叫　　OSIP_ICT_ACK_SENT　ＡＣＫ回应　　OSIP_NICT_REGISTER_SENT　发起注册　　OSIP_NICT_BYE_SENT　ＢＹＥ发出　　OSIP_NICT_CANCEL_SENT　Ｃａｎｃｅｌ发出　　OSIP_NICT_INFO_SENT，OSIP_NICT_OPTIONS_SENT，OSIP_NICT_SUBSCRIBE_SENT，OSIP_NICT_NOTIFY_SENT，OSIP_NICT_UNKNOWN_REQUEST_SENT 　　我们可以看到，eXosip没有对它们作任何处理，我们可以根据自己需要，比如，重发2xx消息前记录一下日志之类的，扩展一下retransmission的处理方式，发起Invite前记录一下通话日志等等。　　OSIP_ICT_STATUS_1XX_RECEIVED　uac收到1xx消息，一般是表示对端正在处理中，这时，主要是设置一下事务状态机的状态值，并对会话中的osip的一些参数根据返回值进行相应设置，里面有许多条件判断，但我们常用的一般是100,180,183的判断而已，暂时可以忽略里面复杂的判断代码。　　OSIP_ICT_STATUS_2XX_RECEIVED uac收到2xx消息，这里主要跟踪一下Register情况下的2xx，表示注册成功，这时会更新一下exosip的注册字段值，以便让eXosip能自动维护uac的注册，ＢＹＥ的２ｘｘ回应是终结消息，Invite的2xx回应，则主要是初始化一下会话相关的数据，表示已成功建立连接。　　其它４ｘｘ，５ｘｘ，６ｘｘ则分别是对应的处理，根据实现情况进行概要的查看即可。　　report_event (je, sip)是代码中用来进行事件处理的一个函数，跟踪后发现，其最终是使用了我们上文提到的ｊｐｉｐｅ管道，以便在状态机外实时观测状态机内的处理信息。　　　　OSIP_NIST_STATUS_XXX_SENT即对应于上面的uac的处理，这里是uas的对应的消息处理，相比较于uac简单一点。　　前面简单介绍了一下大量的回调函数及它们的概要处理逻辑，可能会比较混乱，暂时不用管它，只需要记得一个大概的形象，知道一个ＳＩＰ处理程序是通过osip_set_cb_send_message回调函数来实现真实地发送各种ＳＩＰ消息，并且ＳＩＰ的标准事务模型是由ｏＳＩＰ实现好了，我们只需要给不同的事务状态设置不同的回调处理函数来处理事务，具体的状态变化和内部逻辑不用管就可以了。　　下面来说一下消息处理回调函数用到的ＳＯＣＫ的初始化函数，即我们上面说的除了系统初始化外的网络初始化函数eXosip_listen_addr：　　从上文知道了，系统将初始化两个ＳＯＣＫ，一个ＵＤＰ一个ＴＣＰ，但查看代码发现还有第三个，ＴＣＰｓ的，但好象还不能实用，现在不管它，代码首先是根据传输是ＵＤＰ还是ＴＣＰ来设置对应的数组值，并且如果没有提供ＩＰ地址和端口号，系统会自动取出本机网络接口并创建可用的ＳＯＣＫ（http_port 的方式暂不用考虑）。　　ＳＯＣＫ初始化后，如何开始ＳＩＰ事务的呢？看到这个调用eXosip.j_thread = (void *) osip_thread_create (20000, _eXosip_thread, NULL)，对的，这里启用了一个线程，即，ｅＸｏｓｉｐ是调用ｏＳＩＰ的线程函数（没用系统提供的线程函数，是为了跨平台）进行事务处理的状态机逻辑是在一个线程中处理的，这样就明白了为什么一直没能看到顺序执行下来的程序启动代码了，接下去看，线程实际处理函数是_eXosip_thread，这里面的代码中，我们看到了上文提到的状态机控制开关变量while (eXosip.j_stop_ua == 0)，即，当j_stop_ua设置为1时，osip_thread_exit ()结束事务处理即程序终结，再接下去看，_eXosip_execute是最终的处理函数了，而且它在程序未终结情况下是一直逻辑在执行，注意，要启用ｏＳＩＰ的多线程宏OSIP_MT。　　　　看到_eXosip_execute的代码中有很多时间函数和变量，仔细看，除去一些控制代码，主要处理函数是eXosip_read_message (1, lower_tv.tv_sec, lower_tv.tv_usec)，即取出消息，1表示只取出一条消息，其代码量非常的大，但同样的，其中也许多的控制代码和错误检测代码，我们在查看时可以暂时忽略掉它们。　　eXosip_read_message读取消息时，即没有采用sock的block也没有用非block方式，而是采用了select方式，具体应用可查询fd_set相关文档。　　根据jpipe_read (eXosip.j_socketctl, buf2, 499)，我们可以估计，buf2中应该是保存的我们的控制管道的数据，具体作用至些还没有表现出来，应该是用来反映一些状态机内部的警示之类的信息，实际的ＳＩＰ的处理的状态机的数据是存放在buf中，使用_eXosip_recvfrom获取的，获取后sipevent = osip_parse (buf, i)解析，使用osip_find_transaction_and_add_event (eXosip.j_osip, sipevent)来查询事件对应的事务状态机，找到后就如同其注解所说明的，/* handled by oSIP ! */，即我们上文设置的那一大堆回调函数，至此，我们知道了整个ＳＩＰ应用所处理的大概流程了。　　如果没有找到事务状态机呢？直接丢弃吗？不是的，如果这是一个回应消息，但没有事务状态机处理它，那它是一个错误的，要进行清理后才能丢弃，而如果是一个请求，那更不能丢弃了，因为UAS事务状态机要由它来启动创建的(回应消息表示本地发出了请求消息，即ＵＡＣ行为，事务状态机应是由启动ＵＡＣ的代码初始化启动的)，整个逻辑应该是很简单的，但ｅＸｏｓｉｐ的实现代码却非常多，可见其花了非常多的精力在保证会话的稳定性和应付网络复杂情况上，我们可以对其进行大量的精简来构建满足我们需求的代码实现。　　先来看错误的回应消息的处理函数eXosip_process_response_out_of_transaction，可以看到其代码就是一大堆的赋值语句，XXX= NULL，即将一大堆的运行时变量清空，再调用osip_event_free清空事件，或者就是一些复杂的情况下，需要通过解析现在的运行时数据，从中分析出“可能”的正在等待回应的对端，并发送相关终结通知消息等等，可以根据实际需要进行简化。　　请求事件的处理 eXosip_process_newrequest，首先是对事件进行探测，MSG_IS_INVITE、MSG_IS_ACK、 MSG_IS_REQUEST……，对事件进行所属状态机分类，随后使用_eXosip_transaction_init (&transaction,(osip_fsm_type_t) tx_type,eXosip.j_osip, evt->sip)根据探测结果进行状态机初始化，实际调用的是osip_transaction_init，初始化后即将事件入状态机 osip_transaction_add_event (transaction, evt)，由状态机自动处理后调用相应回调函数处理逻辑了。当然，ｅＸｏｓｉｐ为方便快速开发ＳＩＰ终端应用，在下面又添加了许多自动化的处理代码，来和我们在回调函数中设置的处理代码相区分。　　线程调用的事件处理函数代码最后是 if (eXosip.keep_alive > 0) { 　　_eXosip_keep_alive (); } 　　这段代码印证了上文提到了，keep_alive是用来设置是否自动重新注册，由_eXosip_keep_alive函数来实现自动将eXosip全局变量中保存的注册消息解析后自动根据需要重新向ＳＩＰ服务器发起Ｒｅｇｉｓｔｅｒ注册。　　同样，因为注册消息发起是ＵＡＣ的行为，将它放在这里，可以看出来所有事件消息的事务状态机处理都是在这里，只不过这里只创建ＵＡＳ的事务状态机，ＵＡＣ的事务状态机的创建则要继续到下面找了，从我们的ＹｏｕＴｏｏ软电话代码中可知，发起呼叫和发起注册分别调用了 eXosip_call_send_initial_invite，eXosip_register_send_register这两个函数（另外用到的两个build函数则是分别构建这两个send函数要发送的ＳＩＰ消息），查看这两个函数可知，ＵＡＣ的事务处理状态机是在这里进行初始化的。　　eXosip_register_send_register中可以看到是_eXosip_transaction_init (&transaction, NICT, eXosip.j_osip, reg)初始化ＵＡＣ状态机，实际也同ＵＡＳ是调用的osip_transaction_init函数，同样使用 osip_transaction_add_event (transaction, sipevent)将事件入状态机，状态机随后将自动处理调用相应回调函数处理逻辑了。　　另有osip_new_outgoing_sipmessage(reg)，表示发送消息，到这里，我们应该可以理解，真实的发送操作，是要到由状态机处理后，调用了消息发送回调函数才真正地将注册消息发送出去的。　　同注册消息发送，它是ＮＩＣＴ状态机，呼叫消息的发送是ＩＣＴ，由eXosip_call_send_initial_invite处理，_eXosip_transaction_init (&transaction, ICT, eXosip.j_osip, invite)初始化了状态机，之前还有一个eXosip_call_init是用来初始化eXosip的一些参数的，暂时不管它，同样 osip_new_outgoing_sipmessage (invite)发送呼叫消息，但实际还是要状态机处理后调用消息发送回调函数真实发送呼叫请求函数的，osip_transaction_add_event (transaction, sipevent)则标准地，将事件入状态机，状态机将能处理随后的应用逻辑调用相应的回调函数了。　　好了，作了这么多的分析，我们了解了ｅＸｏｓｉｐ是怎样调用ｏＳＩＰ来形成被我能方便地再次调用的了，可以看到，为了实现最大限度的跨平台和兼容性，代码中有大量的测试代码，宏定义和错误再处理代码，看起来非常吃力，但了解了其主要的调用框架：　　初始化，回调函数设置，ＵＡＣ和ＵＡＳ事务处理状态机的启动，事件处理流程等，就可以基本明白了ｏＳＩＰ各个函数的主要作用和正确的用法了，下一步，可以参考ｅＸｏｓｉｐ来针对某个应用，去除掉大量暂时用不到的代码，来构建一个简单的ＳＩＰ软电话和ＳＩＰ服务器，来进一步深入ｏＳＩＰ学习应用了。　－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－ [下回预告：完全基于ｏＳＩＰ的软电话实现及ｏＳＩＰ进一步学习] （CopyLeft by Meineson | www.mbstudio.cn，原创文章，欢迎转载，但请保留出处说明！）附件为原作者提供的

在编写程序的过程中，我遇到了这样的需求：在基于Windows 9x 或 Windows NT4.0 的程序中，要求确定键盘、鼠标处于空闲状态的时间。查询了有关资料文档以后，发现Windows 9x和Windows NT4.0 没有提供API或系统调用来实现这样的功能。但是，在Windows 2000中提供了一个新的函数：GetLastInputInfo()，这个函数使用结构 LASTINPUTINFO 作为参数： LASTINPUTINFO lpi; lpi.cbSize = sizeof(lpi); GetLastInputInfo(&lpi); 调用函数GetLastInputInfo()以后, 结构成员lpi.dwTime 中的值便是自上次输入事件发生以后的毫秒数。这个值也就是键盘、鼠标处于空闲状态的时间。可惜的是这个函数只能在Windows 2000中使用，Windows 9x 或Windows NT4.0不提供此API函数。那么，如何在Windows 9x 或Windows NT4.0中实现GetLastInputInfo()的功能呢？笔者的方法是利用系统钩子对键盘、鼠标进行监控。 Windows中的钩子实际上是一个回调函数，当用户有输入动作的时候，Windows要调用这个函数。比较典型的系统钩子应用就是键盘钩子和鼠标钩子： HHOOK g_hHookKbd = NULL; HHOOK g_hHookMouse = NULL; 在Windows中，一个系统（相对于一个特定进程而言）钩子必须用一个动态链接库（DLL）来实现。不妨将这个动态链接库命名为IdleUI.dll。这个动态链接库在Windows 9x和Windows NT4.0 中实现了GetLastInputInfo()的功能。IdleUI.dll中有三个函数： BOOL IdleUIInit() void IdleUITerm(); DWORD IdleUIGetLastInputTime(); IdleUIInit()是环境初始化函数，IdleUITerm()是环境清理函数，分别在MFC应用程序的InitInstance() 和 ExitInstance()中调用它们。当用IdleUIInit()做完初始化后，就可以调用第三个函数IdleUIGetLastInputTime()来获取最后一次输入事件后的时钟。从而实现与GetLastInputInfo()一样的功能。程序TestIdleUI.exe是用来测试IdleUI动态库的，程序中调用了IdleUIInit 和 IdleUITerm，同时在程序的客户区中间显示键盘、鼠标空闲的秒数。 void CMainFrame::OnPaint() { CPaintDC dc(this); CString s; DWORD nsec = (GetTickCount() - IdleUIGetLastInputTime())/1000; s.Format( "鼠标或键盘空闲 %d 秒。",nsec); CRect rc; GetClientRect(&rc); dc.DrawText(s, &rc, DT_CENTER|DT_VCENTER|DT_SINGLELINE); } 图一显示了TestIdleUI运行时的情形。图一 TestIdleUI运行画面为了连续的显示，TestIdleUI设置刷新定时器间隔为一秒。 void CMainFrame::OnTimer(UINT) { Invalidate(); UpdateWindow(); } 运行TestIdleUI，当键盘和鼠标什么也不做时，可以看到计时器跳动，当移动鼠标或按键时，计时器又恢复到零，这样就实现了对输入设备空闲状态的监控。实现细节请看下面对IdleUI.dll工作原理的描述：首先调用IdleUIInit ()进行初始化，安装两个钩子：一个用于监控鼠标输入，一个用于监控键盘输入。 HHOOK g_hHookKbd; HHOOK g_hHookMouse; g_hHookKbd = SetWindowsHookEx(WH_KEYBOARD,MyKbdHook,hInst, 0); g_hHookMouse = SetWindowsHookEx(WH_MOUSE,MyMouseHook,hInst, 0); 当用户移动鼠标或按下键盘键时，Windows调用其中的一个钩子并且钩子函数开始记录时间: LRESULT CALLBACK MyMouseHook(in

初学者写java的时候一不小心就遇到错误: 无法从静态上下文中引用非静态变量 this 这样的小报错首先我们需要了解静态（static）方法和变量的特性；关于这个问题是因为大家没有理解和记住这句话：静态方法中不能引用非静态变量！怎样理解这句话呢？我们知道静态方法可以通过所在类直接调用而不需要实例化对象，非静态成员变量则是一个对象的属性它只有在有实例化对象时才存在的，所以

62,614

社区成员

307,326

社区内容

发帖

与我相关

我的任务

社区管理员

加入社区

近7日
近30日
至今

加载中

查看更多榜单

社区公告

暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章