# V568\. It is suspicious that the argument of sizeof\(\) operator is the expression\.

The analyzer detected a potential error: a suspicious expression serves as an argument of the sizeof\(\) operator\.

Suspicious expressions can be arranged in two groups:

1\. An expression attempts to change some variable\.

The sizeof\(\) operator calculates the expression's type and returns the size of this type\. But the expression itself is not calculated\. Here is a sample of suspicious code:

```cpp
int A;
...
size_t size = sizeof(A++);
```

This code does not increment the 'A' variable\. If you need to increment 'A', you'd better rewrite the code in the following way:

```cpp
size_t size = sizeof(A);
A++;
```

2\. Operations of addition, multiplication and the like are used in the expression\.

Complex expressions signal errors\. These errors are usually related to misprints\. For example:

```cpp
SendDlgItemMessage(
  hwndDlg, RULE_INPUT_1 + i, WM_GETTEXT,
  sizeof(buff - 1), (LPARAM) input_buff);
```

The programmer wrote "sizeof\(buff \- 1\)" instead of "sizeof\(buff\) \- 1"\. This is the correct code:

```cpp
SendDlgItemMessage(
  hwndDlg, RULE_INPUT_1 + i, WM_GETTEXT,
  sizeof(buff) - 1, (LPARAM) input_buff);
```

Here is another sample of a misprint in program text:

```cpp
memset(tcmpt->stepsizes, 0,
  sizeof(tcmpt->numstepsizes * sizeof(uint_fast16_t)));
```

The correct code:

```cpp
memset(tcmpt->stepsizes, 0,
  tcmpt->numstepsizes * sizeof(uint_fast16_t));
```

3\. The argument of the sizeof\(\) operator is a pointer to a class\. In most cases this shows that the programmer forgot to dereference the pointer\. 

Example: 

```cpp
class MyClass
{
public:
  int a, b, c;
  size_t getSize() const
  {
    return sizeof(this);
  }
};
```

The getSize\(\) method returns the size of the pointer, not of the object\. Here is a correct variant: 

```cpp
size_t getSize() const
{
  return sizeof(*this);
}
```