C# 最基础知识介绍--多态
目录
- 一、C# 多态性
- 二、静态多态性
- 三、函数重载
- 四、C# 运算符重载
- 1、运算符重载的实现
- 2、可重载和不可重载运算符
- 五、动态多态性
前言:👻🎄
学过编程的人都知道有个名词叫" O O P 思 想 " —— {"面向对象编程"} " 面 向 对 象 编 程 " （Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息 核心思想：封装，继承，多态.
一、C# 多态性
多态是同一个行为具有多个不同表现形式或形态的能力。
多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。 多态性可以是静态的或动态的。在 静态多态性 中，函数的响应是在编译时发生的。在 动态多态性 中，函数的响应是在运行时发生的。 在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。 多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：
现实中，比如我们按下 F1 键这个动作：
- 如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
- 如果当前在 Word 下弹出的就是 Word 帮助；
- 在 Windows 下弹出的就是 Windows 帮助和支持。
- 同一个事件发生在不同的对象上会产生不同的结果。
二、静态多态性
在编译时，函数和对象的连接机制被称为早期绑定，也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为：
- 函数重载
- 运算符重载
三、函数重载
可以在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同。不能重载只有返回类型不同的函数声明。
下面的实例演示了几个相同的函数 Add() ，用于对不同个数参数进行相加处理：
实例：
using System;
namespace PolymorphismApplication
{
public class TestData
{
public int Add(int a, int b, int c)
{
return a + b + c;
}
public int Add(int a, int b)
{
return a + b;
}
}
class Program
{
static void Main(string[] args)
{
TestData dataClass = new TestData();
int add1 = dataClass.Add(1, 2);
int add2 = dataClass.Add(1, 2, 3);
Console.WriteLine("add1 :" + add1);
Console.WriteLine("add2 :" + add2);
}
}
}
下面的实例演示了几个相同的函数 print()，用于打印不同的数据类型：
实例：
using System;
namespace PolymorphismApplication
{
class Printdata
{
void print(int i)
{
Console.WriteLine("输出整型: {0}", i );
}
void print(double f)
{
Console.WriteLine("输出浮点型: {0}" , f);
}
void print(string s)
{
Console.WriteLine("输出字符串: {0}", s);
}
static void Main(string[] args)
{
Printdata p = new Printdata();
// 调用 print 来打印整数
p.print(1);
// 调用 print 来打印浮点数
p.print(1.23);
// 调用 print 来打印字符串
p.print("Hello Runoob");
Console.ReadKey();
}
}
}
当上面的代码被编译和执行时，它会产生下列结果：
输出整型: 1 输出浮点型: 1.23 输出字符串: Hello Runoob
四、C# 运算符重载
您可以重定义或重载 C# 中内置的运算符。因此，程序员也可以使用用户自定义类型的运算符。重载运算符是具有特殊名称的函数，是通过关键字 operator 后跟运算符的符号来定义的。与其他函数一样，重载运算符有返回类型和参数列表。
例如，请看下面的函数：
public static Box operator+ (Box b, Box c)
{
Box box = new Box();
box.length = b.length + c.length;
box.breadth = b.breadth + c.breadth;
box.height = b.height + c.height;
return box;
}
上面的函数为用户自定义的类 Box 实现了加法运算符（+）。它把两个 Box 对象的属性相加，并返回相加后的 Box 对象。
1、运算符重载的实现
下面的程序演示了完整的实现：
实例：
using System;
namespace OperatorOvlApplication
{
class Box
{
private double length; // 长度
private double breadth; // 宽度
private double height; // 高度
public double getVolume()
{
return length * breadth * height;
}
public void setLength( double len )
{
length = len;
}
public void setBreadth( double bre )
{
breadth = bre;
}
public void setHeight( double hei )
{
height = hei;
}
// 重载 + 运算符来把两个 Box 对象相加
public static Box operator+ (Box b, Box c)
{
Box box = new Box();
box.length = b.length + c.length;
box.breadth = b.breadth + c.breadth;
box.height = b.height + c.height;
return box;
}
}
class Tester
{
static void Main(string[] args)
{
Box Box1 = new Box(); // 声明 Box1，类型为 Box
Box Box2 = new Box(); // 声明 Box2，类型为 Box
Box Box3 = new Box(); // 声明 Box3，类型为 Box
double volume = 0.0; // 体积
// Box1 详述
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// Box2 详述
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// Box1 的体积
volume = Box1.getVolume();
Console.WriteLine("Box1 的体积： {0}", volume);
// Box2 的体积
volume = Box2.getVolume();
Console.WriteLine("Box2 的体积： {0}", volume);
// 把两个对象相加
Box3 = Box1 + Box2;
// Box3 的体积
volume = Box3.getVolume();
Console.WriteLine("Box3 的体积： {0}", volume);
Console.ReadKey();
}
}
}
当上面的代码被编译和执行时，它会产生下列结果：
Box1 的体积： 210 Box2 的体积： 1560 Box3 的体积： 5400
2、可重载和不可重载运算符
下表描述了 C# 中运算符重载的能力：
实例针对上述讨论，让我们扩展上面的实例，重载更多的运算符：
实例：
using System;
namespace OperatorOvlApplication
{
class Box
{
private double length; // 长度
private double breadth; // 宽度
private double height; // 高度
public double getVolume()
{
return length * breadth * height;
}
public void setLength( double len )
{
length = len;
}
public void setBreadth( double bre )
{
breadth = bre;
}
public void setHeight( double hei )
{
height = hei;
}
// 重载 + 运算符来把两个 Box 对象相加
public static Box operator+ (Box b, Box c)
{
Box box = new Box();
box.length = b.length + c.length;
box.breadth = b.breadth + c.breadth;
box.height = b.height + c.height;
return box;
}
public static bool operator == (Box lhs, Box rhs)
{
bool status = false;
if (lhs.length == rhs.length && lhs.height == rhs.height
&& lhs.breadth == rhs.breadth)
{
status = true;
}
return status;
}
public static bool operator !=(Box lhs, Box rhs)
{
bool status = false;
if (lhs.length != rhs.length || lhs.height != rhs.height
|| lhs.breadth != rhs.breadth)
{
status = true;
}
return status;
}
public static bool operator <(Box lhs, Box rhs)
{
bool status = false;
if (lhs.length < rhs.length && lhs.height
< rhs.height && lhs.breadth < rhs.breadth)
{
status = true;
}
return status;
}
public static bool operator >(Box lhs, Box rhs)
{
bool status = false;
if (lhs.length > rhs.length && lhs.height
> rhs.height && lhs.breadth > rhs.breadth)
{
status = true;
}
return status;
}
public static bool operator <=(Box lhs, Box rhs)
{
bool status = false;
if (lhs.length <= rhs.length && lhs.height
<= rhs.height && lhs.breadth <= rhs.breadth)
{
status = true;
}
return status;
}
public static bool operator >=(Box lhs, Box rhs)
{
bool status = false;
if (lhs.length >= rhs.length && lhs.height
>= rhs.height && lhs.breadth >= rhs.breadth)
{
status = true;
}
return status;
}
public override string ToString()
{
return String.Format("({0}, {1}, {2})", length, breadth, height);
}
}
class Tester
{
static void Main(string[] args)
{
Box Box1 = new Box(); // 声明 Box1，类型为 Box
Box Box2 = new Box(); // 声明 Box2，类型为 Box
Box Box3 = new Box(); // 声明 Box3，类型为 Box
Box Box4 = new Box();
double volume = 0.0; // 体积
// Box1 详述
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// Box2 详述
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// 使用重载的 ToString() 显示两个盒子
Console.WriteLine("Box1： {0}", Box1.ToString());
Console.WriteLine("Box2： {0}", Box2.ToString());
// Box1 的体积
volume = Box1.getVolume();
Console.WriteLine("Box1 的体积： {0}", volume);
// Box2 的体积
volume = Box2.getVolume();
Console.WriteLine("Box2 的体积： {0}", volume);
// 把两个对象相加
Box3 = Box1 + Box2;
Console.WriteLine("Box3： {0}", Box3.ToString());
// Box3 的体积
volume = Box3.getVolume();
Console.WriteLine("Box3 的体积： {0}", volume);
//comparing the boxes
if (Box1 > Box2)
Console.WriteLine("Box1 大于 Box2");
else
Console.WriteLine("Box1 不大于 Box2");
if (Box1 < Box2)
Console.WriteLine("Box1 小于 Box2");
else
Console.WriteLine("Box1 不小于 Box2");
if (Box1 >= Box2)
Console.WriteLine("Box1 大于等于 Box2");
else
Console.WriteLine("Box1 不大于等于 Box2");
if (Box1 <= Box2)
Console.WriteLine("Box1 小于等于 Box2");
else
Console.WriteLine("Box1 不小于等于 Box2");
if (Box1 != Box2)
Console.WriteLine("Box1 不等于 Box2");
else
Console.WriteLine("Box1 等于 Box2");
Box4 = Box3;
if (Box3 == Box4)
Console.WriteLine("Box3 等于 Box4");
else
Console.WriteLine("Box3 不等于 Box4");
Console.ReadKey();
}
}
}
当上面的代码被编译和执行时，它会产生下列结果：
Box1： (6, 7, 5) Box2： (12, 13, 10) Box1 的体积： 210 Box2 的体积： 1560 Box3：(18, 20, 15) Box3 的体积： 5400 Box1 不大于 Box2 Box1 小于 Box2 Box1 不大于等于 Box2 Box1 小于等于 Box2 Box1 不等于 Box2 Box3 等于 Box4
五、动态多态性
C# 允许您使用关键字 abstract 创建抽象类，用于提供接口的部分类的实现。当一个派生类继承自该抽象类时，实现即完成。 抽象类 包含抽象方法，抽象方法可被派生类实现。派生类具有更专业的功能。
请注意，下面是有关抽象类的一些规则：
- 不能创建一个抽象类的实例。
- 不能在一个抽象类外部声明一个抽象方法。
- 通过在类定义前面放置关键字
sealed，可以将类声明为密封类。当一个类被声明为sealed时，它不能被继承。抽象类不能被声明为sealed。
下面的程序演示了一个抽象类：
实例：
using System;
namespace PolymorphismApplication
{
abstract class Shape
{
abstract public int area();
}
class Rectangle: Shape
{
private int length;
private int width;
public Rectangle( int a=0, int b=0)
{
length = a;
width = b;
}
public override int area ()
{
Console.WriteLine("Rectangle 类的面积：");
return (width * length);
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle r = new Rectangle(10, 7);
double a = r.area();
Console.WriteLine("面积： {0}",a);
Console.ReadKey();
}
}
}
当上面的代码被编译和执行时，它会产生下列结果：
Rectangle 类的面积： 面积： 70
当有一个定义在类中的函数需要在继承类中实现时，可以使用 虚方法 。
虚方法是使用关键字 virtual 声明的。
虚方法可以在不同的继承类中有不同的实现。
对虚方法的调用是在运行时发生的。
动态多态性是通过 抽象类 和 虚方法 实现的。
以下实例创建了 Shape 基类，并创建派生类 Circle、 Rectangle、Triangle， Shape 类提供一个名为 Draw 的虚拟方法，在每个派生类中重写该方法以绘制该类的指定形状。
实例:
using System;
using System.Collections.Generic;
public class Shape
{
public int X { get; private set; }
public int Y { get; private set; }
public int Height { get; set; }
public int Width { get; set; }
// 虚方法
public virtual void Draw()
{
Console.WriteLine("执行基类的画图任务");
}
}
class Circle : Shape
{
public override void Draw()
{
Console.WriteLine("画一个圆形");
base.Draw();
}
}
class Rectangle : Shape
{
public override void Draw()
{
Console.WriteLine("画一个长方形");
base.Draw();
}
}
class Triangle : Shape
{
public override void Draw()
{
Console.WriteLine("画一个三角形");
base.Draw();
}
}
class Program
{
static void Main(string[] args)
{
// 创建一个 List<Shape> 对象，并向该对象添加 Circle、Triangle 和 Rectangle
var shapes = new List<Shape>
{
new Rectangle(),
new Triangle(),
new Circle()
};
// 使用 foreach 循环对该列表的派生类进行循环访问，并对其中的每个 Shape 对象调用 Draw 方法
foreach (var shape in shapes)
{
shape.Draw();
}
Console.WriteLine("按下任意键退出。");
Console.ReadKey();
}
}
当上面的代码被编译和执行时，它会产生下列结果：
- 画一个长方形
- 执行基类的画图任务
- 画一个三角形
- 执行基类的画图任务
- 画一个圆形
- 执行基类的画图任务
- 按下任意键退出。
下面的程序演示通过虚方法 area() 来计算不同形状图像的面积：
实例:
using System;
namespace PolymorphismApplication
{
class Shape
{
protected int width, height;
public Shape( int a=0, int b=0)
{
width = a;
height = b;
}
public virtual int area()
{
Console.WriteLine("父类的面积：");
return 0;
}
}
class Rectangle: Shape
{
public Rectangle( int a=0, int b=0): base(a, b)
{
}
public override int area ()
{
Console.WriteLine("Rectangle 类的面积：");
return (width * height);
}
}
class Triangle: Shape
{
public Triangle(int a = 0, int b = 0): base(a, b)
{
}
public override int area()
{
Console.WriteLine("Triangle 类的面积：");
return (width * height / 2);
}
}
class Caller
{
public void CallArea(Shape sh)
{
int a;
a = sh.area();
Console.WriteLine("面积： {0}", a);
}
}
class Tester
{
static void Main(string[] args)
{
Caller c = new Caller();
Rectangle r = new Rectangle(10, 7);
Triangle t = new Triangle(10, 5);
c.CallArea(r);
c.CallArea(t);
Console.ReadKey();
}
}
}
当上面的代码被编译和执行时，它会产生下列结果：
Rectangle 类的面积： 面积：70 Triangle 类的面积： 面积：25
总结💬
到此这篇关于C# 最基础知识介绍--多态的文章就介绍到这了,更多相关C# 多态内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
相关推荐
-
C#中多态性的实现
C#语言三大特性:继承,封装,多态 一:多态性 多态是指一个行为具有多个不同表现形式的能力,在C#中通过多态性的检测时机可以分为静态多态性和动态多态性 静态多态性:函数重载和运算符重载 动态多态性:抽象方法.重写方法.隐藏方法 二:函数重载(overlode) --函数名必须相同 --函数参数类型不同 --函数参数个数不同 --函数参数顺序不同 三:抽象(abstract) --包含抽象函数的类,类也必须定义为抽象的 --抽象函数只有定义没有函数体,并且必须定义为public --抽象类中可以包
-
C#与.net高级编程 C#的多态介绍
用virtual关键字标记的方法称为虚方法,如果子类希望改变虚方法的实现细节就必须使用 override关键字. 抽象类 abstract关键字 防止创建毫无意义的基本类,使用abstract关键字创建抽象基类,防止被实例化 使用abstract关键字创建抽象方法,强制每一个子类重写特定的方法,abstract成员没有提供任何实现. (注:抽象方法只可以定义在抽象类中,如果不是这样的话,就会收到编译器错误) 成员投影 如果派生类定义的成员和定义在蕨类中的成员一致,派生类投影了父类的版本. 如:我
-
详解c# 多态
多态是同一个行为具有多个不同表现形式或形态的能力. 多态性意味着有多重形式.在面向对象编程范式中,多态性往往表现为"一个接口,多个功能". 多态性可以是静态的或动态的.在静态多态性中,函数的响应是在编译时发生的.在动态多态性中,函数的响应是在运行时发生的. 在 C# 中,每个类型都是多态的,因为包括用户定义类型在内的所有类型都继承自 Object. 多态就是同一个接口,使用不同的实例而执行不同操作,如图所示: 现实中,比如我们按下 F1 键这个动作: 如果当前在 Flash 界面下弹出
-
C#中的多态深入理解
封装.继承.多态,面向对象的三大特性,前两项理解相对容易,但要理解多态,特别是深入的了解,对于初学者而言可能就会有一定困难了.我一直认为学习OO的最好方法就是结合实践,封装.继承在实际工作中的应用随处可见,但多态呢?也许未必,可能不经意间用到也不会把它跟"多态"这个词对应起来.在此抛砖引玉,大家讨论,个人能力有限,不足之处还请指正. 之前看到过类似的问题:如果面试时主考官要求你用一句话来描述多态,尽可能的精炼,你会怎么回答?当然答案有很多,每个人的理解和表达不尽相同,但我比较趋向这样描
-
c#基础学习之多态
最近在看一本书<你必须知道的.Net>,书涵盖的内容比较多,对于c#,.Net平台以往所学的零散东西有了慢慢的总结和新的认识.把一些基础的东西记录于此. 先说说多态吧: 1.基类继承式多态 如书中所说,基类继承式多态的关键是继承体系的设计与实现.书中举了个简单的列子 复制代码 代码如下: Files myFile=new WORDFile(); myFile.open(); myFile是一个父类Files变量,保持了指向子类WORDFile实例的引用,然后调用一个虚方法Open,具体的调用则
-
C#多态的三种实现方式(小结)
C#实现多态主要有3种方法,虚方法,抽象类,接口 1 虚方法 在父类的方法前面加关键字virtual, 子类重写该方法时在方法名前面加上override关键字,例如下面的Person类的SayHello方法 class Person { public Person(string name) { this.Name = name; } string _name; public string Name { get => _name; set => _name = value; } //父类方法加v
-
对C# 多态的理解
面向对象三要素:封装.继承.多态. 封装和继承,这两个比较好理解,但要理解多态的话,可就稍微有点难度了.今天,我们就来讲讲多态的理解. 我们应该经常会看到面试题目:请谈谈对多态的理解. 其实呢,多态非常简单,就一句话:调用同一种方法产生了不同的结果. 具体实现方式有三种. 一.重载 重载很简单. public string GetValue(string x) { return x; } public string GetValue(string x, string y) { return x+
-
深入理解c#多态
继承概念 多态:即一个接口,多个功能 同一种操作作用于不同的对象,可以有不同的解释,产生不同的执行结果 多态性可以是静态的或动态的.在静态多态性中,函数的响应是在编译时发生的.在动态多态性中,函数的响应是在运行时发生的 静态多态性 在静态多态性中,函数的响应是在编译时发生的 父类中如果有方法需要子类重写,可以将该方法标记为虚方法 虚方法必须在父类中有实现,空实现也可以 虚方法子类可以重写,也可以不重写 实现静态多态性有两种方法; 函数重载 运算符重载 函数重载 即在同一范围中对同一函数名的多重定
-
C#类的多态性详解
第一种:编译时的多态性,直接这样说不知道说啥?程序执行过程主要分为三步:编译,链接,运行.在编译时体现的多态性是通过方法的重载来实现的.方法的重载我们听过,就是一个类对象调用若干同名,但参数类型.个数不同.类对象是根据参数类型,个数来决定调用哪个同名方法,实现何种操作.C#语言的方法重载与C++.java基本是一样的,但是C#还包含C++的运算符重载,java里面没有这个概念. 第二种:运行时的多态性,是在系统运行时,调用一个名字相同,参数类型也相同以及个数也完全一样的方法,但会完成不同的操作.
-
C# 最基础知识介绍--多态
目录 一.C# 多态性 二.静态多态性 三.函数重载 四.C# 运算符重载 1.运算符重载的实现 2.可重载和不可重载运算符 五.动态多态性 前言:
-
java网络编程基础知识介绍
网络基础知识 1.OSI分层模型和TCP/IP分层模型的对应关系 这里对于7层模型不展开来讲,只选择跟这次系列主题相关的知识点介绍. 2.七层模型与协议的对应关系 网络层 ------------ IP(网络之间的互联协议) 传输层 ------------ TCP(传输控制协议).UDP(用户数据报协议) 应用层 ------------ Telnet(Internet远程登录服务的标准协议和主要方式).FTP(文本传输协议).HTTP(超文本传送协议) 3.IP地址和端口号 1.ip地址用于
-
ES6基础知识介绍
目录 一.ECMAScript和JavaScript关系 二.let命令 三.const命令 四.变量的解构赋值 1.数组的解构赋值 2.对象的解构赋值 一.ECMAScript和JavaScript关系 JavaScript 的创造者 Netscape 公司,决定将 JavaScript 提交给标准化组织 ECMA,希望这种语言能够成为国际标准,但是JavaScript本身也已经被 Netscape 公司注册为商标,后面的标准都由ECMA制定,取名ECMAScript. 那么ES6这个版本引入
-
ASP.NET母版页基础知识介绍
模板页是做什么的? 利用模板页可以方便快捷的创建统一风格的ASP.NET网站,并且容易管理和维护,提高了效率. 模板页为网页定义所需要的外观和标准,在母版的基础上创建包含显示内容的各个内容页.当用户请求内容页时,这些内容页与母版页合并,这样,模板页的布局与内容页的布局就可以组合在一起输出了. 模板页一般用来: 1.通过修改模板页来处理网页的通用功能. 2.可以方便的创建一组控件和代码,并应用于一组网页. 3.通过允许控制占位符控件的呈现方式,模板页可以在细节上控制最终页的布局. 模板页与普通页
-
PowerShell中的变量基础知识介绍
本文介绍在PowerShell中,如何使用变量.变量可以存储程序中的数量,比如开发者的赋值.命令的执行结果等. 变量拿来干嘛的,不用我多说了,写过程序的兄弟们都知道:如果程序中没有变量,那真的就不能让程序了!连批处理里面都有变量了,那PowerShell中自然就更不能没有. 1.PowerShell中的变量都是对象 PowerShell中的变量是基于.NET Framework的,所以PowerShell中的变量跟.NET中的变量一样:都是对象,通通都是对象! 复制代码 代码如下: $i=1 $
-
ORACLE 12C PDB 维护基础知识介绍
先说基本用法: 先按11G之前进行 conn / as sysdba; create user test identifed by test; ORA-65096: 公用用户名或角色名无效. 查官方文档得知"试图创建一个通用用户,必需要用C##或者c##开头",这时候心里会有疑问,什么是common user?不管先建成功了再说 create C##user test identifed by test; 创建成功 SQL>show con_name; CON_NAME ----
-
PHP基础知识介绍
php中的整形数是有符号的,不能表示无符号整数,当整形数超出范围时,会自动从整形数转化成float数,可以用php_int_size常量来查看php整数类型所占字节,一般为4个字节,所以可以估算出整形数的范围,最高位数符号位.也可以用php_int_max常量来查看int的最大值. 小知识点: 1. 当变量为0.0或"0"在布尔变量中均表示false: 2. 字符串变量用双引号时其中变量和转义字符可以按照其定义正常输出,而用单引号输出内容时它会原样输出其内容,即转义字符或变量不
-
正则表达式模式匹配字符串基础知识
介绍 在实际项目中有个功能的实现需要解析一些特定模式的字符串.而在已有的代码库中,在已实现的部分功能中,都是使用检测特定的字符,使用这种方法的缺点是: 逻辑上很容易出错 很容易漏掉对一些边界条件的检查 代码复杂难以理解.维护 性能差 看到代码库中有一个cpp,整个cpp两千多行代码,有个方法里,光解析字符串的就有400余行!一个个字符对比过去,真是不堪入目.而且上面很多注释都已经过期,很多代码的书写风格也各不相同,基本可以判断是过了很多人手的. 在这种情况下,基本没办法还沿着这条老路走下去,自
-
Lua教程（二）：基础知识、类型与值介绍
一.基础知识: 1. 第一个程序和函数: 在目前这个学习阶段,运行Lua程序最好的方式就是通过Lua自带的解释器程序,如: 复制代码 代码如下: /> lua > print("Hello World") Hello World 这样我们就可以以交互性的方式输入lua代码,并立即得到执行结果了.对于代码块较少的测试程序来说,这种方式确实是非常方便的,然而对于相对复杂的程序而言,这种方式就不是很合适了.如果是这样,我们可以将Lua代码保存到一个独立
-
PHP内核介绍及扩展开发指南—基础知识
一. 基础知识 本章简要介绍一些Zend引擎的内部机制,这些知识和Extensions密切相关,同时也可以帮助我们写出更加高效的PHP代码. 1.1 PHP变量的存储 1.1.1 zval结构 Zend使用zval结构来存储PHP变量的值,该结构如下所示: 复制代码 代码如下: typedef union _zvalue_value { long lval; /* long value */ double dval; /* double value */ struct { char *val;