D语言

D语言概述 D语言开发环境设置 D语言基本语法 D语言变量 D语言数据类型 D语言枚举Enums D语言常值 D语言运算符 D语言循环 D语言while循环 D语言for循环 D语言do...while循环 D语言嵌套循环 D语言break语句 D语言continue语句 D语言决策语句 D语言if...else语句 D语言switch语句 D语言函数 D语言字符 D语言字符串-String D语言数组 D语言关联数组 D语言指针 D语言元组 D语言结构体 D语言联合体 D语言范围 D语言别名 D语言模块 D语言模板 D语言常量 D语言文件I/O D语言并发 D语言异常处理 契约式编程 D语言条件编译 D语言类和对象 D语言类成员函数 类的访问修饰符 构造函数和析构函数 this指针 类指针 类的静态成员 类继承 重载 一元运算符重载 二元运算符重载 比较操作符重载 D语言封装 D语言接口 D语言抽象类
  1. D语言
  2. D语言指针

D语言指针

D编程指针是很容易和有趣学习。一些D编程任务的指针进行更容易和其他D编程任务，如动态存储器分配，不能没有它们来执行。一个简单的指针如下所示。


而不是直接指向变量一样，指针所指向的值赋给变量的地址。正如你所知道的每个变量是一个内存位置和每个存储单元都有其定义的地址，可以使用符号来访问(＆)运算，是指在存储器中的地址。认为这将打印中定义的变量的地址如下：

View Raw Code?
1
2
3
4
5
6
7
8
9
10
import std.stdio;
void main ()
{
int var1;
writeln("Address of var1 variable: ",&var1);
char var2[10];
writeln("Address of var2 variable: ",&var2);
}
当上面的代码被编译并执行，它会产生什么结果如下： 
Address of var1 variable: 7FFF52691928
Address of var2 variable: 7FFF52691930

什么是指针？

指针是一个变量，它的值是另一个变量的地址。如同任何变量或常量，必须声明一个指针，然后才能使用它。一个指针变量声明的一般形式是：

View Raw Code?
1
type *var-name;
其中，type是指针的基本类型;它必须是一个有效的编程类型和var-name是指针变量的名称。用来声明一个指针的星号是用于乘法相同的星号。然而，在这个语句中的星号是被用来指定一个变量的指针。以下是有效的指针声明：
View Raw Code?
1
2
3
4
int *ip; // web3er to an integer
double *dp; // web3er to a double
float *fp; // web3er to a float
char *ch // web3er to character
所有指针的值的实际数据类型，整数，浮点数，字符，或以其他方式是否是相同的，代表一个内存地址的十六进制数。不同数据类型的指针之间的唯一区别是变量或常数，该指针指向的数据类型。

D编程语言使用指针：

有几个重要的业务，我们将与指针做的非常频繁。 (a)我们定义一个指针变量(b)分配一个变量的地址的指针(c)在指针变量中可用的地址最终进入的值。这是通过使用一元运算符*，返回位于其操作数指定的地址变量的值来完成。下面的示例使用这些操作：

View Raw Code?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import std.stdio;
void main ()
{
int var = 20; // actual variable declaration.
int *ip; // web3er variable
ip = &var; // store address of var in web3er variable
writeln("Value of var variable: ",var);
writeln("Address stored in ip variable: ",ip);
writeln("Value of *ip variable: ",*ip);
}
当上面的代码被编译并执行，它会产生什么结果如下： 
Value of var variable: 20
Address stored in ip variable: 7FFF5FB7E930
Value of *ip variable: 20

Null 指针

它始终是一个好习惯，对NULL指针分配给案件的指针变量你没有确切的地址进行分配。这样做是在变量声明的时候。分配空指针被称为空指针(null)。

空指针是一个常数为零的几个标准库，包括iostream中定义的值。考虑下面的程序：

View Raw Code?
1
2
3
4
5
6
7
import std.stdio;
void main ()
{
int *ptr = null;
writeln("The value of ptr is " , ptr) ;
}
让我们编译和运行上面的程序，这将产生以下结果：
View Raw Code?
1
The value of ptr is null
在大多数的操作系统，程序不允许在地址0访问内存，因为内存是由操作系统保留。然而，存储器地址0具有特殊的意义;它表明，该指针不旨在指向一个可访问的存储器位置。但按照惯例，如果一个指针包含空（零）值，它被假定为不指向什么东西。

要检查空指针，可以使用一个if语句如下：

View Raw Code?
1
2
if(ptr) // succeeds if p is not null
if(!ptr) // succeeds if p is null

因此，如果所有未使用的指针被赋予空值，并且避免使用空指针，能避免未初始化的指针的意外误操作。很多时候，未初始化的变量举行一些垃圾值，就很难调试程序。

指针运算

可以对指针的使用加减乘除四则运算符： ++, --, +, -

为了理解指针的算术运算，让我们认为，ptr是一个整数的指针，假设它32位指向的地址1000整数，让我们上的指针执行以下算术运算： 

ptr++

ptr将指向位置1004，因为每次ptr递增，它会指向下一个整数。此操作将指针移动到下一个内存位置，而不在内存中的位置影响实际值。如果ptr指向一个字符的地址是1000，那么上面的操作将指向位置1001，因为下一个字符将在1001。

递增一个指针：

我们优选使用在我们的程序，而不是一个数组的指针，因为变量指针可以递增，这是不能被增加，因为它是一个常量指针数组名不同。下面的程序将变量指针来访问数组中的每个元素成功：

View Raw Code?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import std.stdio;
const int MAX = 3;
void main ()
{
int var[MAX] = [10, 100, 200];
int *ptr = &var[0];
for (int i = 0; i < MAX; i++, ptr++)
{
writeln("Address of var[" , i , "] = ",ptr);
writeln("Value of var[" , i , "] = ",*ptr);
}
}
当上面的代码被编译并执行，它会产生一些结果如下：
View Raw Code?
1
2
3
4
5
6
Address of var[0] = 18FDBC
Value of var[0] = 10
Address of var[1] = 18FDC0
Value of var[1] = 100
Address of var[2] = 18FDC4
Value of var[2] = 200

指针与数组

指针和数组有很大的关系。然而，指针和数组不完全互换。例如，考虑下面的程序：

View Raw Code?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import std.stdio;
const int MAX = 3;
void main ()
{
int var[MAX] = [10, 100, 200];
int *ptr = &var[0];
var.ptr[2] = 290;
ptr[0] = 220;
for (int i = 0; i < MAX; i++, ptr++)
{
writeln("Address of var[" , i , "] = ",ptr);
writeln("Value of var[" , i , "] = ",*ptr);
}
}
在上面的程序中，可以看到var.ptr[2]来设置第二个元素和ptr[0]这是用来设置第零个元素。递增运算符可以使用ptr但不使用var。

当上面的代码被编译并执行，它会产生一些结果如下：

View Raw Code?
1
2
3
4
5
6
Address of var[0] = 18FDBC
Value of var[0] = 220
Address of var[1] = 18FDC0
Value of var[1] = 100
Address of var[2] = 18FDC4
Value of var[2] = 290

指针的指针

一个指针，指针是多个间接或链指针的一种形式。通常情况下，一个指针包含一个变量的地址。当我们定义一个指向指针的指针，第一指针包含第二指针，它指向包含实际值如下所示的位置的地址。

View Raw Code?
1
int **var;
当目标值被间接地通过一个指向指针指向的，访问该值要求的星号运算符被应用两次，如下面的例子所示：
View Raw Code?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import std.stdio;
const int MAX = 3;
void main ()
{
int var = 3000;
writeln("Value of var :" , var);
int *ptr = &var;
writeln("Value available at *ptr :" ,*ptr);
int **pptr = &ptr;
writeln("Value available at **pptr :",**pptr);
}
让我们编译和运行上面的程序，这将产生以下结果： 
Value of var :3000
Value available at *ptr :3000
Value available at **pptr :3000

指针传递给函数

D编程允许将一个指针传递给一个函数。要做到这一点，只需声明该函数的参数为指针类型。

下面一个简单的例子，我们传递一个指向函数的指针。

View Raw Code?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import std.stdio;
void main ()
{
// an int array with 5 elements.
int balance[5] = [1000, 2, 3, 17, 50];
double avg;
avg = getAverage( &balance[0], 5 ) ;
writeln("Average is :" , avg);
}
double getAverage(int *arr, int size)
{
int i;
double avg, sum = 0;
for (i = 0; i < size; ++i)
{
sum += arr[i];
}
avg = sum/size;
return avg;
}
当上面的代码一起编译和执行时，它会产生下列结果：
View Raw Code?
1
Average is :214.4
返回指针的函数

考虑下面的函数，它将使用第一个数组元素的指针，即，地址返回数字10。

View Raw Code?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import std.stdio;
void main ()
{
int *p = getNumber();
for ( int i = 0; i < 10; i++ )
{
writeln("*(p + " , i , ") : ",*(p + i));
}
}
int * getNumber( )
{
static int r [10];
for (int i = 0; i < 10; ++i)
{
r[i] = i;
}
return &r[0];
}
当上面的代码一起编译并执行，它会产生一些结果如下： 
*(p + 0) : 0
*(p + 1) : 1
*(p + 2) : 2
*(p + 3) : 3
*(p + 4) : 4
*(p + 5) : 5
*(p + 6) : 6
*(p + 7) : 7
*(p + 8) : 8
*(p + 9) : 9

指向数组的指针

数组名是一个常量指针数组的第一个元素。因此，声明：

View Raw Code?
1
double balance[50];
balance是一个指针，指向与balance[0]，这是阵列平衡的第一个元素的地址。因此，下面的程序片段分配p为balance的第一个元素的地址：
View Raw Code?
1
2
3
double *p;
double balance[10];
p = balance;
它是合法的，使用数组名作为常量指针，反之亦然。因此，*(balance + 4) 处于访问balance[4]数据的一种合法方法。

一旦存储p中第一个元素的地址，可以使用* p*（p +1），*（p+2）等访问数组元素。下面是该例子，以显示所有上面讨论的概念：

View Raw Code?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import std.stdio;
void main ()
{
// an array with 5 elements.
double balance[5] = [1000.0, 2.0, 3.4, 17.0, 50.0];
double *p;
p = &balance[0];
// output each array element's value
writeln("Array values using web3er " );
for ( int i = 0; i < 5; i++ )
{
writeln( "*(p + ", i, ") : ", *(p + i));
}
}
让我们编译和运行上面的程序，这将产生以下结果： 
Array values using web3er 
*(p + 0) : 1000
*(p + 1) : 2
*(p + 2) : 3.4
*(p + 3) : 17
*(p + 4) : 50
站内导航
HTML5 | CSS3 | JavaScrip | HTML DOM | JSON | PHP7 | XML | XML DOM | XSLT | DTD | XML Schema | 开发手册 | php手册 | 破解软件 | 技术分享 | Blog
联系我们

邮箱 626512443@qq.com
电话 18611320371(微信)
QQ群 235681453

友情链接
百郎科技 | Linux命令大全 | xin站大全 | 厦门SEO | 探趣吧 | 北京医院跑腿

Copyright © 2015-2024

备案号：京ICP备15003423号-3