c - "dereferencing"这个词是从哪里来的？

Question

本题将从草稿中抽取信息N1570 ，所以 C11 基本上。

通俗地说，取消引用指针意味着将一元 * 运算符应用于指针。文档草案中只有一个地方存在“取消引用”一词(没有“取消引用”的实例)，并且在脚注中:

102) [...]

Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer, an address inappropriately aligned for the type of object pointed to, and the address of an object after the end of its lifetime

据我所知，一元 * 运算符实际上称为“间接运算符”，如 §6.5.3.2 所示:

6.5.3.2 Address and indirection operators

4 The unary * operator denotes indirection. [...]

同样，它在附件§J.2中明确称为间接运算符:

— The value of an object is accessed by an array-subscript [], member-access . or −>, address &, or indirection * operator or a pointer cast in creating an address constant (6.6).

那么在 C 中谈论“解引用指针”是否正确，或者这是否过于迂腐？术语从何而来？ (由于 §6.5.2.1，我可以对 [] 被称为“尊重”给予通行证)

Answer 1

K&R v1

如果看The C Programming Language，在第一版(1978 年)中，使用了术语“间接”。

例子

2.12 Precedence and Order of Evaluation

[…]

Chapter 5 discusses * (indirection) and & (address of).

,

7.2 Unary operators

[…]

The unary * operator means indirection: the expression must be a pointer, and the result is an lvalue referring to the object to which the expression points.

它也列在 INDEX 中，例如

* indirection operator 89, 187

5.1 节的较长摘录

5.1 Pointers and Addresses

      Since a pointer contains the address of an object, it is possible to access the object “indirectly” through the pointer. Suppose that x is a variable, say an int, and that px is a pointer, created in some as yet unspecified way. The unary operator c gives the address of an object, so the statement

px = &x;

assigns the address of x to the variable px; px is now said to “point to” x. The & operator can be applied only to variables and array elements; constructs like &(x+1 ) and &3 are illegal. It is also illegal to take the address of a register variable.

    The unary operator * treats its operand as the address off the ultimate target, and accesses that address to fetch the contents. Thus if y is alos an int,

y = *px;

assigns to y the contents of whatever px points to. So the sequence

px = &x;
y = *px;

assigns the same value to y as does

y = x;

K&R v2

在第二版中出现了术语解引用。

5.1 Pointers and Addresses

The unary operator * is the indirection or dereferencing operator; when applied to a pointer, it accesses the object the pointer points to. Suppose that x and y are integers and ip is a pointer to int. This artificial sequence shows how to declare a pointer and how to use & and *:

[…]

---

先前的用法

然而，该术语(“很多”)较旧，例如可以在

A survey of some issues concerning abstract data types , 1974. 例如 pp24/25。此处说明与 ALGOL 68、PASCAL、SIMULA 67 的连接。

The mechanism by which pointers are transformed into values by a language is known as 'dereferencing', a form of coercion (discussed later). Consider the statement

 p := q;

Depending upon the types of p and q, there are several possible interpretations.

Let '@' be a dereferencing operator (i.e. if p points to j , then @p is the same as j) and '#' be a referencing operation (i.e. if p points to j , then p is the same as #j). The following table indicates the possible actions a language might take to perform the assignment:

                       |                                         
                       |   type of p                             
                       |                                         
                       |   t         ref t     ref ref t . . .   
                       |                                         
        ---------------------------------------------------------
                       |                                         
           t           |  p←q        p←#q       p←##q            
                       |             @p←q       @p←#q            
                       |                        @@p←q            
type                   |                                         
of                     |                                         
q          ref t       |  p←@q       p←q        p←#q             
                       |             @p←@q      @p←q             
                       |                        @@p←@q           
                       |                                         
                       |                                         
           ref ref t   |  p←@@q      p←@q       p←q              
             .         |             @p←@@q     @p←@q            
             .         |                        @@p←@@q          
             .         |                                         
                       |                                         
                       |                                         

[…]

---

铸币

它的用法还有其他几个例子。虽然我无法找到它的确切位置和时间(至少现在还没有)。 (1974 年的论文至少很有趣。)

---

为了好玩，查看诸如 net.unix-wizards 之类的邮件列表通常也很有用。一个example from Peter Lamb at Melbourne Uni (11/28/83):

Dereferencing NULL pointers is yet another example of idiots who write 'portable' code, assuming however, that THEIR machine is the only one on which it will ever run: the same sorts of people who designed cpio with binary headers. Even on a VAX, dereferencing NULL will get you garbage: sure, *(char *)NULL and *(short *)NULL return you 0, but *(int *)NULL will give you 1024528128 !!!!.

[…]

---

Ed1。添加

没有提到“取消引用”，但仍然；一个有趣的读物是 Ritchie:The Development of the C Language ✝

这里也一直使用术语“间接” – 但是/和/等等。语言之间的联系有些详细。鉴于例如，该术语的使用因此很有趣。像上面提到的 1974 年的论文。

作为间接作为概念和语法的示例，例如第 12 页。

    An accident of syntax contributed to the perceived complexity of the language. The indirection operator, spelled * in C, is syntactically a unary prefix operator, just as in BCPL and B. This works well in simple expressions, but in more complex cases, parentheses are required to direct the parsing.

[…]

There are two effects occurring. Most important, C has a relatively rich set of ways of describing types (compared, say, with Pascal). Declarations in languages as expressive as C– Algol 68, for example – describe objects equally hard to understand, simply because the objects themselves are complex. A second effect owes to details of the syntax. Declarations in C must be read in an ‘inside-out’ style that many find difficult to grasp [Anderson 80].

---

在这个结合中，可能还值得一提 ANSI C89 并提及:

3.1.2.5 Types

A pointer to void may not be dereferenced, although such a pointer may be converted to a normal pointer type which may be dereferenced.

• Draft ANSI C Standard (ANSI X3J11/88-090) , (由 Wikipedia 提供)
• Rationale for American National Standard for Information Systems – Programming Language – C

Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer, an address inappropriately aligned for the type of object pointed to, or the address of an object that has automatic storage duration when execution of the block in which the object is declared and of all enclosed blocks has terminated.

(我现在必须重新阅读其中一些文档。)