Member access operators

Операторы доступа к членам позволяют обращаться к членам своих операндов.

Нижний индекс

Выражение индексации массива имеет вид

где

Выражение оператора индексации является lvalue-выражением , тип которого совпадает с типом объекта, на который указывает pointer-expression .

По определению, оператор индексации E1 [ E2 ] точно идентичен выражению * ( ( E1 ) + ( E2 ) ) . Если pointer-expression является выражением массива, оно подвергается преобразованию lvalue-to-rvalue и становится указателем на первый элемент массива.

В соответствии с определением сложения указателя и целого числа , результатом является элемент массива с индексом, равным результату integer-expression (или, если pointer-expression указывал на i-й элемент некоторого массива, индекс результата будет равен i плюс результат integer-expression )

Примечание: подробности о многомерных массивах смотрите в разделе array .

#include <stdio.h>
int main(void)
{
    int a[3] = {1,2,3};
    printf("%d %d\n", a[2],  // n == 3
                      2[a]); // same, n == 3
    a[2] = 7; // subscripts are lvalues
    int n[2][3] = {{1,2,3},{4,5,6}};
    int (*p)[3] = &n[1]; // elements of n are arrays
    printf("%d %d %d\n", (*p)[0], p[0][1], p[0][2]); // access n[1][] via p
    int x = n[1][2]; // applying [] again to the array n[1]
    printf("%d\n", x);
    printf("%c %c\n", "abc"[2], 2["abc"]); // string literals are arrays too
}

3 3
4 5 6
6
c c

Разыменование

Выражение разыменования или косвенной адресации имеет вид

где

Если pointer-expression является указателем на функцию, результатом оператора разыменования является обозначение функции для этой функции.

Если pointer-expression является указателем на объект, результатом будет lvalue выражение , которое обозначает указываемый объект.

Разыменование нулевого указателя, указателя на объект вне времени его жизни (висячий указатель), невыровненного указателя или указателя с неопределённым значением является неопределённым поведением, за исключением случаев, когда оператор разыменования аннулируется применением оператора взятия адреса к его результату, как в & * E .

#include <stdio.h>
int main(void)
{
    int n = 1;
    int* p = &n;
    printf("*p = %d\n", *p); // значение *p - это то, что хранится в n
    *p = 7; // *p является lvalue
    printf("*p = %d\n", *p);
}

*p = 1
*p = 7

Адрес

Выражение взятия адреса имеет вид

где

Оператор взятия адреса создаёт не-lvalue адрес своего операнда, подходящий для инициализации указателя на тип операнда. Если операнд является обозначением функции (1) , результат представляет собой указатель на функцию. Если операнд является объектом (2) , результат представляет собой указатель на объект.

Если операнд является оператором разыменования, никаких действий не предпринимается (так что допустимо применять &* к нулевому указателю), за исключением того, что результат не является lvalue.

Если операнд является выражением индекса массива, никаких действий, кроме преобразования массива в указатель и сложения, не выполняется, поэтому &a[N] допустимо для массива размера N (получение указателя за последний элемент допустимо, разыменование - нет, но разыменование компенсируется в этом выражении).

int f(char c) { return c;}
int main(void)
{
   int n = 1;
   int *p = &n; // адрес объекта n
   int (*fp)(char) = &f; // адрес функции f
   int a[3] = {1,2,3};
   int *beg=a, *end=&a[3]; // то же самое, что end = a+3
}

Доступ к членам

Выражение доступа к члену имеет вид

где

Выражение доступа к члену обозначает именованный член struct или union , указанный его левым операндом. Оно имеет ту же value category , что и его левый операнд.

Если левый операнд имеет квалификаторы const или volatile , результат также имеет эти квалификаторы. Если левый операнд является atomic , поведение не определено.

Примечание: кроме идентификаторов, которые именуют объекты структурного или объединённого типа, следующие выражения могут иметь структурный или объединённый тип: assignment , function call , comma operator , conditional operator , и compound literal .

#include <stdio.h>
struct s {int x;};
struct s f(void) { return (struct s){1}; }
int main(void)
{
    struct s s;
    s.x = 1; // ок, изменяет член структуры s
    int n = f().x; // f() - выражение типа struct s
//  f().x = 1; // Ошибка: это выражение доступа к члену не является lvalue
    const struct s sc;
//  sc.x = 3;  // Ошибка: sc.x является константой, нельзя присвоить значение
    union { int x; double d; } u = {1};
    u.d = 0.1; // изменяет активный член объединения
}

Доступ к члену через указатель

Выражение доступа к члену имеет вид

где

Выражение доступа к члену через указатель обозначает именованный член struct или union типа, на который указывает его левый операнд. Его категория значения всегда является lvalue

Если тип, на который указывает левый операнд, является const или volatile квалифицированным, результат также будет квалифицирован. Если тип, на который указывает левый операнд, является atomic , поведение не определено.

#include <stdio.h>
struct s {int x;};
int main(void)
{
    struct s s={1}, *p = &s;
    p->x = 7; // изменяет значение s.x через указатель
    printf("%d\n", p->x); // выводит 7
}

Отчеты о дефектах

Следующие отчеты о дефектах, изменяющих поведение, были применены ретроактивно к ранее опубликованным стандартам C.

Ссылки

Смотрите также

• Приоритет операторов