This HTML5 document contains 62 embedded RDF statements represented using HTML+Microdata notation.

The embedded RDF content will be recognized by any processor of HTML5 Microdata.

Namespace Prefixes

PrefixIRI
dctermshttp://purl.org/dc/terms/
dbohttp://dbpedia.org/ontology/
foafhttp://xmlns.com/foaf/0.1/
dbpedia-eshttp://es.dbpedia.org/resource/
n14https://global.dbpedia.org/id/
dbthttp://dbpedia.org/resource/Template:
dbpedia-ukhttp://uk.dbpedia.org/resource/
rdfshttp://www.w3.org/2000/01/rdf-schema#
freebasehttp://rdf.freebase.com/ns/
dbpedia-cshttp://cs.dbpedia.org/resource/
rdfhttp://www.w3.org/1999/02/22-rdf-syntax-ns#
owlhttp://www.w3.org/2002/07/owl#
wikipedia-enhttp://en.wikipedia.org/wiki/
dbpedia-frhttp://fr.dbpedia.org/resource/
dbpedia-zhhttp://zh.dbpedia.org/resource/
dbphttp://dbpedia.org/property/
dbchttp://dbpedia.org/resource/Category:
provhttp://www.w3.org/ns/prov#
xsdhhttp://www.w3.org/2001/XMLSchema#
goldhttp://purl.org/linguistics/gold/
wikidatahttp://www.wikidata.org/entity/
dbrhttp://dbpedia.org/resource/

Statements

Subject Item
dbr:Dereference_operator
rdf:type
dbo:Company
rdfs:label
Оператор розіменування Opérateur de déréférencement Operador de desreferencia 解引用运算符 Dereference Dereference operator
rdfs:comment
El operador de 'desreferencia' u operador de indirección, identificado por el asterisco "*", es un operador unario usado en lenguajes de programación que incluyen variables de tipo , como el lenguaje C y varios de sus descendientes. Opera sobre una variable de tipo puntero y devuelve una expresión equivalente al valor contenido en la dirección apuntada por dicho puntero. Esta operación recibe el nombre de "desreferenciar". Por ejemplo: int x = 0;int *puntero_a_x = &x; // * se usa para declarar un puntero*puntero_a_x = 1; // * es el operador de indireccion// x ahora contiene 1 Dereference je v programování operace, kterou se získává přístup k proměnné, na níž se odkazuje ukazatel nebo reference. V některých případech a jazycích je dereference implicitní (např. reference v C++), ve většině jazyků je však třeba použít unární operátor dereference. L'opérateur de déréférencement ou d'indirection est un opérateur unaire (c'est-à-dire avec un seul opérande) que l'on trouve dans les langages qui incluent des pointeurs, tels que les langages C et C++, où il est désigné par le symbole * (astérisque). Il nécessite pour opérande un pointeur et renvoie la valeur stockée à l'adresse contenue dans le pointeur. On dit pour cela que l'on "déréférence" le pointeur. Par exemple, le code C suivant : affecte 42 à la variable <b>x</b> à l'aide de l'opérateur de déréférencement et d'un pointeur sur la variable <b>x</b> . 解引用运算符（dereference operator）或称间址运算符（indirection operator）。C语言编程语言家族中常表示为"*" (一个星号)，为单元运算符，作用于1个指针变量，返回该指针地址的等效<a href="/wiki/%E5%B7%A6%E5%80%BC" class="mw-redirect" title="左值">左值</a>。这被称为指针的解引用。例如： int x; int *p; // * is used in the declaration: // p is a pointer to an integer, since (after dereferencing), // *p is an integer x = 0; // now x == 0 p = &x; // & takes the address of x // now *p == 0, since p == &x and therefore *p == x *p = 1; // equivalent to x = 1, since p == &x // now *p == 1 and x == 1 在C语言中，&是解引用运算符*的逆运算。因此*&s等价于s。例如： In computer programming, the dereference operator or indirection operator, sometimes denoted by "*" (i.e. an asterisk), is a unary operator (i.e. one with a single operand) found in C-like languages that include pointer variables. It operates on a pointer variable, and returns an <a href="/wiki/Value_(computer_science)#lrvalue" title="Value (computer science)">l-value</a> equivalent to the value at the pointer address. This is called "dereferencing" the pointer. For example, the C code assigned 1 to variable <b>x</b> by using the dereference operator and a pointer to the variable <b>x</b>.
dcterms:subject
dbc:Operators_(programming) dbc:Unary_operations
dbo:wikiPageID
10068450
dbo:wikiPageRevisionID
1114868540
dbo:wikiPageWikiLink
dbr:Sigil_(computer_programming) dbr:Indirection dbr:Shell_scripting dbr:Exclamation_mark dbr:%5E dbr:Main_function dbr:Syntactic_sugar dbr:Segmentation_fault dbc:Operators_(programming) dbr:C_(programming_language) dbr:C_syntax dbr:C++ dbc:Unary_operations dbr:Computer_programming dbr:List_of_C-family_programming_languages dbr:Argv dbr:BCPL dbr:Unary_operator dbr:Asterisk dbr:Scalar_variable dbr:Makefile dbr:Pointer_(computer_programming) dbr:Pascal_(programming_language) dbr:Memory_address
owl:sameAs
dbpedia-zh:解引用运算符 n14:4j7UQ dbpedia-uk:Оператор_розіменування dbpedia-fr:Opérateur_de_déréférencement dbpedia-cs:Dereference freebase:m.02q0rlc wikidata:Q5261748 dbpedia-es:Operador_de_desreferencia
dbp:wikiPageUsesTemplate
dbt:Short_description dbt:Further dbt:Unreferenced dbt:! dbt:Mono
dbo:abstract
L'opérateur de déréférencement ou d'indirection est un opérateur unaire (c'est-à-dire avec un seul opérande) que l'on trouve dans les langages qui incluent des pointeurs, tels que les langages C et C++, où il est désigné par le symbole * (astérisque). Il nécessite pour opérande un pointeur et renvoie la valeur stockée à l'adresse contenue dans le pointeur. On dit pour cela que l'on "déréférence" le pointeur. Par exemple, le code C suivant : int x = 21; int *p; // * est utilisée pour la déclaration: // p est un pointeur sur un entier, // *p est un entier p = &x; // & renvoie l'adresse de x // maintenant *p == 21, puisque p == &x et que *p == x *p = 42; // équivaut à écrire x = 42, car p == &x // donc *p == 42 et x == 42 car p est un pointeur qui contient l'adresse de x, // modifier *p revient à modifier x affecte 42 à la variable <b>x</b> à l'aide de l'opérateur de déréférencement et d'un pointeur sur la variable <b>x</b> . Dereference je v programování operace, kterou se získává přístup k proměnné, na níž se odkazuje ukazatel nebo reference. V některých případech a jazycích je dereference implicitní (např. reference v C++), ve většině jazyků je však třeba použít unární operátor dereference. Operátor dereference se zapisuje různě. V jazyce Pascal se na rozdíl od většiny ostatních jazyků zapisuje operátor za ukazatel; ve standardním Pascalu se pro dereferenci používá symbol šipka (↑), který však není v mnoha znakových sadách obsažen, proto bývá nahrazován znakem stříška (^) nebo zavináč (@); v Turbo Pascalu se zavináč naopak používá pro získání adresy. V jazyce C se operátor dereference někdy nazývá indirection operator a používá se pro něj symbol hvězdička (*). V mnoha skriptovacích jazycích se pro dereferenci používá symbol dolar ($), který primárně slouží pro vyhodnocení obsahu proměnné. 解引用运算符（dereference operator）或称间址运算符（indirection operator）。C语言编程语言家族中常表示为"*" (一个星号)，为单元运算符，作用于1个指针变量，返回该指针地址的等效<a href="/wiki/%E5%B7%A6%E5%80%BC" class="mw-redirect" title="左值">左值</a>。这被称为指针的解引用。例如： int x; int *p; // * is used in the declaration: // p is a pointer to an integer, since (after dereferencing), // *p is an integer x = 0; // now x == 0 p = &x; // & takes the address of x // now *p == 0, since p == &x and therefore *p == x *p = 1; // equivalent to x = 1, since p == &x // now *p == 1 and x == 1 在C语言中，&是解引用运算符*的逆运算。因此*&s等价于s。例如： p = &s; // the address of s has been assigned to p; p == &s; // *p is equivalent to s 结构s的成员a的值可表示为s.a。若指针p指向s (即p == &s), s.a等价于(*p).a，也可用结构解引用运算符作为语法糖缩写表示为p->a： p = &s; // the address of s has been assigned to p; p == &s; // s.a is equivalent to (*p).a // s.a is equivalent to p->a // (*p).a is equivalent to p->a Unix的外壳脚本以及一些工具软件如Makefile中，美元符"$"为解引用运算符，用于把变量名字转译为其内容。 In computer programming, the dereference operator or indirection operator, sometimes denoted by "*" (i.e. an asterisk), is a unary operator (i.e. one with a single operand) found in C-like languages that include pointer variables. It operates on a pointer variable, and returns an <a href="/wiki/Value_(computer_science)#lrvalue" title="Value (computer science)">l-value</a> equivalent to the value at the pointer address. This is called "dereferencing" the pointer. For example, the C code int x; int *p; // * is used in the declaration: // p is a pointer to an integer, since (after dereferencing), // *p is an integer x = 0; // now x == 0 p = &x; // & takes the address of x // now *p == 0, since p == &x and therefore *p == x *p = 1; // equivalent to x = 1, since p == &x // now *p == 1 and x == 1 assigned 1 to variable <b>x</b> by using the dereference operator and a pointer to the variable <b>x</b>. El operador de 'desreferencia' u operador de indirección, identificado por el asterisco "*", es un operador unario usado en lenguajes de programación que incluyen variables de tipo , como el lenguaje C y varios de sus descendientes. Opera sobre una variable de tipo puntero y devuelve una expresión equivalente al valor contenido en la dirección apuntada por dicho puntero. Esta operación recibe el nombre de "desreferenciar". Por ejemplo: int x = 0;int *puntero_a_x = &x; // * se usa para declarar un puntero*puntero_a_x = 1; // * es el operador de indireccion// x ahora contiene 1 El código anterior asigna el valor 1 a la variable x usando el operador de desreferencia sobre un puntero a dicha variable.
gold:hypernym
dbr:Operator
prov:wasDerivedFrom
wikipedia-en:Dereference_operator?oldid=1114868540&ns=0
dbo:wikiPageLength
7904
foaf:isPrimaryTopicOf
wikipedia-en:Dereference_operator