Shulou(Shulou.com)06/01 Report--

This article mainly explains "Why don't you unquote invalid pointers in C++?" interested friends may wish to have a look. The method introduced in this paper is simple, fast and practical. Next, let the editor take you to learn "Why don't you unquote invalid pointers in C++?"

ES.65: do not dereference invalid pointers

Reason (reason)

Dereferencing invalid pointers such as null is an undefined behavior that usually immediately leads to program crashes, error results, or memory corruption.

Note (Note)

This rule is obvious and well known, but it is difficult to follow. It will bring a good code style, more full library support, does not cost a lot of money, but can eliminate illegal static parsing. This is an important part of the discussion on the type of C++ and the resource security model.

See also: (see)

Use RAII to avoid lifetime problems.

Use RAII to avoid lifecycle problems.

Use unique_ptr to avoid lifetime problems.

Use unique_ptr to avoid lifecycle problems

Use shared_ptr to avoid lifetime problems.

Use shared_ptr to avoid lifecycle problems

Use references when nullptr isn't a possibility.

If a null pointer is not possible, use a reference

Use not_null to catch unexpected nullptr early.

Use not_null to catch unexpected null pointers as early as possible.

Use the bounds profile to avoid range errors.

Use boundary rule groups to avoid scope errors.

Example (sample)

Void f ()

{

Int x = 0

Int* p = & x

If (condition ()) {

Int y = 0

P = & y

} / / invalidates p

* p = 42; / / BAD, p might be invalid if the branch was taken

}

To solve this problem, either extend the life cycle of the object that the object pointer is intended to point to, or shorten the life cycle of the pointer (move the dereferencing operation to before the end of the life cycle of the object you are pointing to. )

Void F1 ()

{

Int x = 0

Int* p = & x

Int y = 0

If (condition ()) {

P = & y

}

* p = 42; / / OK, p points to x or y and both are still in scope

}

Unfortunately, most invalid pointer problems are harder to spot and harder to fix.

Unfortunately, most invalid pointer problems are difficult to find and difficult to fix.

Example (sample)

Void f (int* p)

{

Int x = * p; / / BAD: how do we know that p is valid?

}

There is a lot of such code. After a lot of testing, you can act in most cases, but it's hard to tell if a pointer is empty if you just look at the part. Therefore, null pointers are also one of the main sources of errors. There are many ways to deal with this potential problem:

Void F1 (int* p) / / deal with nullptr

{

If (! P) {

/ / deal with nullptr (allocate, return, throw, make p point to something, whatever

}

Int x = * p

}

There are two potential problems with testing for nullptr:

There are two potential problems with checking whether the pointer is null:

It is not always obvious what to do what to do if we find nullptr

It is not always clear what to do when a null pointer is found.

The test can be redundant and/or relatively expensive

The inspection may be superfluous and / or costly.

It is not obvious if the test is to protect against a violation or part of the required logic.

It is difficult to determine whether this check is just to prevent violations or part of the necessary logic.

Void f2 (int* p) / / state that p is not supposed to be nullptr

{

Assert (p)

Int x = * p

}

This approach comes at a price only if the assertion check is valid and can provide useful information for the compiler / parser. The effect would be better if C++ was directly supported by the agreement (contracts):

Void f3 (int* p) / / state that p is not supposed to be nullptr

[[expects: p]]

{

Int x = * p

}

Alternatively, we could use gsl::not_null to ensure that p is not the nullptr.

In addition, we can use gsl::not_null to ensure that p is not a null pointer.

Void f (not_null p)

{

Int x = * p

}

These remedies take care of nullptr only. Remember that there are other ways of getting an invalid pointer.

This improvement only deals with null pointers. Don't forget that there are other forms of invalid pointers.

Example (sample)

Void f (int* p) / / old code, doesn't use owner

{

Delete p

}

Void g () / / old code: uses naked new

{

Auto Q = new int {7}

F (Q)

Int x = * Q; / / BAD: dereferences invalid pointer

} Example (sample)

Void f ()

{

Vector v (10)

Int* p = & v [5]

V.push_back (99); / / could reallocate v's elements

Int x = * p; / / BAD: dereferences potentially invalid pointer

} Enforcement (implementation recommendations)

This rule is part of the lifetime safety profile

This rule is part of the lifecycle rule group

Flag a dereference of a pointer that points to an object that has gone out of scope

If the object the pointer points to is already outside its life cycle, mark its dereferencing operation.

Flag a dereference of a pointer that may have been invalidated by assigning a nullptr

If the pointer is invalid because it is set to a null pointer, mark its dereferencing operation.

Flag a dereference of a pointer that may have been invalidated by a delete

If it is invalid because the object pointed to by the pointer is destroyed, mark its dereferencing operation.

Flag a dereference to a pointer to a container element that may have been invalidated by dereference

If the container element pointed to by the pointer is invalid due to dereferencing, mark its dereferencing operation.

At this point, I believe you have a deeper understanding of "why not dereference invalid pointers in C++". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.