当前位置：文江博客话题详情

如何在 C# 中声明 void 指针

发布于 2024-09-06 00:49:14 字数 26 浏览 4 评论 0原文

在 C# 中如何声明 void 指针？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

违心° 2024-09-13 00:49:14

void*identifier;

但它需要处于不安全状态：

unsafe
{
    void* identifier;
}

并且项目必须允许不安全代码。

void* identifier;

But it needs to be in unsafe as:

unsafe
{
    void* identifier;
}

And unsafe code has to have been allowed for the project.

回复收藏 0 原文

烟花易冷人易散 2024-09-13 00:49:14

我假设你的意思是在托管代码中，因为你的问题很短，除了假设之外什么都做不了。

我认为您要么正在寻找 IntPtr ，要么只是寻找任何 object 引用（这是基本类型，并且是空指针的基本等效项 - 对“某物”的引用）。除非您指的是空指针，在这种情况下您要查找IntPtr.Zero。

回复收藏 0 原文

幻梦 2024-09-13 00:49:14

来自 http://msdn.microsoft.com/en -us/library/y31yhkeb%28VS.80%29.aspx

Visual Studio 2005其他版本中有 22 个版本（共 43 个版本）评价为有帮助 - 评分
在不安全的上下文中，类型也可能是指针类型
作为值类型或引用类型。指针类型声明需要
以下形式之一：
类型*标识符； void*identifier; //允许但不推荐 Any
以下类型可能是指针类型：
sbyte、byte、short、ushort、int、uint、long、ulong、char、float、
双精度、小数或布尔值。
任何枚举类型。
任何指针类型。
包含非托管类型字段的任何用户定义的结构类型
仅。
指针类型不继承自对象，并且不存在转换
指针类型和对象之间。此外，装箱和拆箱不
支持指点。但是，您可以在不同的指针之间进行转换
类型以及指针类型和整型类型之间的关系。
当您在同一个声明中声明多个指针时，* 是
仅与基础类型一起编写，而不是作为每个类型的前缀
指针名称。例如：
int* p1, p2, p3; // 好的
int *p1, *p2, *p3; // 在 C# 中无效
指针不能指向引用或包含以下内容的结构
引用，因为对象引用可能是
即使指针指向它，垃圾也会被收集。 GC 不
跟踪某个对象是否被任何指针所指向
类型。
myType*类型的指针变量的值是a的地址
myType 类型的变量。以下是指针类型的示例
声明：
示例说明
int* p
p是一个指向整数的指针
int** p
p 是一个指向整数的指针
int*[] p
p 是指向整数的一维指针数组
字符* p
p是一个指向字符的指针
void* p
p 是一个指向未知类型的指针
指针间接运算符 * 可用于访问内容
位于指针变量所指向的位置。例如，对于
以下声明，
int* myVariable; 表达式 *myVariable 表示 int 变量
在 myVariable 中包含的地址中找到。
不能将间接寻址运算符应用于 void* 类型的指针。
但是，您可以使用强制转换将 void 指针转换为任何其他指针
指针类型，反之亦然。
指针可以为空。将间接运算符应用于 null
指针导致实现定义的行为。
请注意，在方法之间传递指针可能会导致未定义
行为。示例通过返回指向局部变量的指针
Out 或 Ref 参数或作为函数结果。如果指针已设置
在固定块中，它指向的变量可能不再是
已修复。
下表列出了可以使用的运算符和语句
在不安全上下文中对指针进行操作：
运算符/语句的使用
*
执行指针间接寻址。
->
通过指针访问结构体的成员。
[]
索引指针。
&
获取变量的地址。
++ 和 --
增加和减少指针。
和-
执行指针算术。
==、!=、<、>、<= 和 >=
比较指针。
堆栈分配
在堆栈上分配内存。
固定语句
临时修复变量以便可以找到其地址。
C# 语言规范有关详细信息，请参阅以下内容
C# 语言规范中的部分：
18 条不安全代码

From http://msdn.microsoft.com/en-us/library/y31yhkeb%28VS.80%29.aspx

Visual Studio 2005Other Versions22 out of 43 rated this helpful - Rate
this topic In an unsafe context, a type may be a pointer type as well
as a value type or a reference type. A pointer type declaration takes
one of the following forms:
type* identifier; void* identifier; //allowed but not recommended Any
of the following types may be a pointer type:
sbyte, byte, short, ushort, int, uint, long, ulong, char, float,
double, decimal, or bool.
Any enum type.
Any pointer type.
Any user-defined struct type that contains fields of unmanaged types
only.
Pointer types do not inherit from object and no conversions exist
between pointer types and object. Also, boxing and unboxing do not
support pointers. However, you can convert between different pointer
types and between pointer types and integral types.
When you declare multiple pointers in the same declaration, the * is
written along with the underlying type only, not as a prefix to each
pointer name. For example:
int* p1, p2, p3; // Ok
int *p1, *p2, *p3; // Invalid in C#
A pointer cannot point to a reference or to a struct that contains
references because it is possible for an object reference to be
garbage collected even if a pointer is pointing to it. The GC does not
keep track of whether an object is being pointed to by any pointer
types.
The value of the pointer variable of type myType* is the address of a
variable of type myType. The following are examples of pointer type
declarations:
Example Description
int* p
p is a pointer to an integer
int** p
p is a pointer to pointer to an integer
int*[] p
p is a single-dimensional array of pointers to integers
char* p
p is a pointer to a char
void* p
p is a pointer to an unknown type
The pointer indirection operator * can be used to access the contents
at the location pointed to by the pointer variable. For example, for
the following declaration,
int* myVariable; the expression *myVariable denotes the int variable
found at the address contained in myVariable.
You cannot apply the indirection operator to a pointer of type void*.
However, you can use a cast to convert a void pointer to any other
pointer type, and vice versa.
A pointer can be null. Applying the indirection operator to a null
pointer results in an implementation-defined behavior.
Be aware that passing pointers between methods can cause undefined
behavior. Examples are returning a pointer to a local variable via an
Out or Ref parameter or as the function result. If the pointer was set
in a fixed block, the variable to which it points may no longer be
fixed.
The following table lists the operators and statements that can
operate on pointers in an unsafe context:
Operator/Statement Use
*
to perform pointer indirection.
->
to access a member of a struct through a pointer.
[]
to index a pointer.
&
to obtain the address of a variable.
++ and --
to increment and decrement pointers.
and -
to perform pointer arithmetic.
==, !=, <, >, <=, and >=
to compare pointers.
stackalloc
to allocate memory on the stack.
fixed statement
to temporarily fix a variable in order that its address may be found.
C# Language Specification For more information, see the following
section in the C# Language Specification:
18 Unsafe Code