Tất cả các hành vi không xác định phổ biến mà một lập trình viên C ++ nên biết là gì? [đóng cửa]

Tất cả các hành vi không xác định phổ biến mà một lập trình viên C ++ nên biết là gì?

Nói, như:

a[i] = i++;

Con trỏ

• Dereferences một NULLcon trỏ
• Hủy bỏ hội nghị một con trỏ được trả về bởi phân bổ "mới" có kích thước bằng 0
• Sử dụng các con trỏ tới các đối tượng có thời gian kết thúc (ví dụ: ngăn xếp các đối tượng được phân bổ hoặc các đối tượng bị xóa)
• Hủy bỏ hội nghị một con trỏ chưa được khởi tạo chắc chắn
• Thực hiện số học con trỏ mang lại kết quả bên ngoài các ranh giới (ở trên hoặc dưới) của một mảng.
• Hủy bỏ con trỏ tại một vị trí nằm ngoài phần cuối của một mảng.
• Chuyển đổi con trỏ thành các đối tượng của các loại không tương thích
• Sử dụng memcpyđể sao chép bộ đệm chồng chéo .

Bộ đệm tràn

• Đọc hoặc ghi vào một đối tượng hoặc mảng ở phần bù âm hoặc vượt quá kích thước của đối tượng đó (tràn / chồng đống)

Số nguyên tràn

• Đã tràn số nguyên
• Đánh giá một biểu thức không được xác định theo toán học
• Giá trị dịch chuyển trái theo số lượng âm (dịch chuyển phải theo số lượng âm được xác định)
• Thay đổi giá trị theo số lượng lớn hơn hoặc bằng số bit trong số (ví dụ: int64_t i = 1; i <<= 72không xác định)

Các loại, diễn viên và Const

• Truyền một giá trị số thành một giá trị không thể được biểu thị bằng loại mục tiêu (trực tiếp hoặc qua static_cast)
• Sử dụng một biến tự động trước khi nó được gán chắc chắn (ví dụ int i; i++; cout << i;:)
• Sử dụng giá trị của bất kỳ đối tượng nào khác volatilehoặc sig_atomic_tkhi nhận tín hiệu
• Cố gắng sửa đổi một chuỗi ký tự hoặc bất kỳ đối tượng const nào khác trong suốt vòng đời của nó
• Nối hẹp với một chuỗi ký tự rộng trong quá trình tiền xử lý

Chức năng và mẫu

• Không trả về giá trị từ hàm trả về giá trị (trực tiếp hoặc bằng cách chuyển từ khối thử)
• Nhiều định nghĩa khác nhau cho cùng một thực thể (lớp, mẫu, liệt kê, hàm nội tuyến, hàm thành viên tĩnh, v.v.)
• Đệ quy vô hạn trong việc khởi tạo các mẫu
• Gọi một hàm sử dụng các tham số hoặc liên kết khác nhau đến các tham số và liên kết mà hàm được định nghĩa là sử dụng.

OOP

• Phá hủy tầng của các đối tượng với thời gian lưu trữ tĩnh
• Kết quả của việc gán cho các đối tượng chồng chéo một phần
• Nhập lại một cách đệ quy một hàm trong quá trình khởi tạo các đối tượng tĩnh của nó
• Thực hiện các cuộc gọi hàm ảo đến các hàm ảo thuần túy của một đối tượng từ hàm tạo hoặc hàm hủy của nó
• Đề cập đến các thành viên phi lý của các đối tượng chưa được xây dựng hoặc đã bị phá hủy

Tập tin nguồn và tiền xử lý

• Tệp nguồn không trống không kết thúc bằng dòng mới hoặc kết thúc bằng dấu gạch chéo ngược (trước C ++ 11)
• Dấu gạch chéo ngược theo sau là một ký tự không phải là một phần của mã thoát được chỉ định trong hằng số ký tự hoặc chuỗi (đây là định nghĩa triển khai được xác định trong C ++ 11).
• Vượt quá giới hạn triển khai (số khối lồng nhau, số hàm trong chương trình, không gian ngăn xếp có sẵn ...)
• Các giá trị số tiền xử lý không thể được biểu thị bằng long int
• Chỉ thị tiền xử lý ở phía bên trái của định nghĩa macro giống như hàm
• Tự động tạo mã thông báo được xác định trong #ifbiểu thức

Được phân loại

• Gọi thoát trong khi hủy chương trình với thời lượng lưu trữ tĩnh

Thứ tự mà các tham số chức năng được ước tính là hành vi không xác định . (Điều này sẽ không làm cho chương trình của bạn bị sập, phát nổ hoặc đặt mua pizza ... không giống như hành vi không xác định .)

Yêu cầu duy nhất là tất cả các tham số phải được đánh giá đầy đủ trước khi hàm được gọi.

Điều này:

// The simple obvious one.
callFunc(getA(),getB());

Có thể tương đương với điều này:

int a = getA();
int b = getB();
callFunc(a,b);

Hoặc này:

int b = getB();
int a = getA();
callFunc(a,b);

Nó có thể là một trong hai; tùy thuộc vào trình biên dịch. Kết quả có thể quan trọng, tùy thuộc vào tác dụng phụ.

Trình biên dịch có thể tự do sắp xếp lại các phần đánh giá của một biểu thức (giả sử ý nghĩa là không thay đổi).

Từ câu hỏi ban đầu:

a[i] = i++;

// This expression has three parts:
(a) a[i]
(b) i++
(c) Assign (b) to (a)

// (c) is guaranteed to happen after (a) and (b)
// But (a) and (b) can be done in either order.
// See n2521 Section 5.17
// (b) increments i but returns the original value.
// See n2521 Section 5.2.6
// Thus this expression can be written as:

int rhs  = i++;
int lhs& = a[i];
lhs = rhs;

// or
int lhs& = a[i];
int rhs  = i++;
lhs = rhs;

Kiểm tra khóa kép. Và một sai lầm dễ mắc phải.

A* a = new A("plop");

// Looks simple enough.
// But this can be split into three parts.
(a) allocate Memory
(b) Call constructor
(c) Assign value to 'a'

// No problem here:
// The compiler is allowed to do this:
(a) allocate Memory
(c) Assign value to 'a'
(b) Call constructor.
// This is because the whole thing is between two sequence points.

// So what is the big deal.
// Simple Double checked lock. (I know there are many other problems with this).
if (a == null) // (Point B)
{
    Lock   lock(mutex);
    if (a == null)
    {
        a = new A("Plop");  // (Point A).
    }
}
a->doStuff();

// Think of this situation.
// Thread 1: Reaches point A. Executes (a)(c)
// Thread 1: Is about to do (b) and gets unscheduled.
// Thread 2: Reaches point B. It can now skip the if block
//           Remember (c) has been done thus 'a' is not NULL.
//           But the memory has not been initialized.
//           Thread 2 now executes doStuff() on an uninitialized variable.

// The solution to this problem is to move the assignment of 'a'
// To the other side of the sequence point.
if (a == null) // (Point B)
{
    Lock   lock(mutex);
    if (a == null)
    {
        A* tmp = new A("Plop");  // (Point A).
        a = tmp;
    }
}
a->doStuff();

// Of course there are still other problems because of C++ support for
// threads. But hopefully these are addresses in the next standard.

Sở thích của tôi là "đệ quy vô hạn trong việc khởi tạo các mẫu" bởi vì tôi tin rằng đó là lần duy nhất có hành vi không xác định xảy ra tại thời điểm biên dịch.

Chỉ định một hằng số sau khi tước constness bằng cách sử dụngconst_cast<> :

const int i = 10; 
int *p =  const_cast<int*>( &i );
*p = 1234; //Undefined

Bên cạnh hành vi không xác định , còn có hành vi được xác định thực hiện khó chịu không kém .

Hành vi không xác định xảy ra khi một chương trình làm một cái gì đó mà kết quả không được chỉ định bởi tiêu chuẩn.

Hành vi xác định thực hiện là một hành động của một chương trình mà kết quả không được xác định bởi tiêu chuẩn, nhưng việc thực hiện được yêu cầu phải ghi lại. Một ví dụ là "Multibyte ký tự chữ", từ câu hỏi Stack Overflow Có trình biên dịch C không biên dịch được điều này không?.

Hành vi được xác định theo triển khai chỉ cắn bạn khi bạn bắt đầu chuyển (nhưng nâng cấp lên phiên bản mới của trình biên dịch cũng đang chuyển!)

Các biến chỉ có thể được cập nhật một lần trong một biểu thức (về mặt kỹ thuật một lần giữa các điểm chuỗi).

int i =1;
i = ++i;

// Undefined. Assignment to 'i' twice in the same expression.

Một sự hiểu biết cơ bản về các giới hạn môi trường khác nhau. Danh sách đầy đủ nằm trong mục 5.2.4.1 của thông số kỹ thuật C. Ở đây có một ít;

• 127 tham số trong một chức năng
• 127 đối số trong một lệnh gọi hàm
• 127 tham số trong một định hướng vĩ mô
• 127 đối số trong một lệnh gọi macro
• 4095 ký tự trong một dòng nguồn logic
• 4095 ký tự trong một chuỗi ký tự theo nghĩa đen hoặc chuỗi ký tự rộng (sau khi ghép)
• 65535 byte trong một đối tượng (chỉ trong môi trường được lưu trữ)
• 15 cấp độ cho #inculled fi les
• 1023 nhãn trường hợp cho câu lệnh chuyển đổi (không bao gồm nhãn cho câu lệnh chuyển đổi bất kỳ)

Tôi thực sự hơi ngạc nhiên khi giới hạn 1023 trường hợp nhãn cho câu lệnh chuyển đổi, tôi có thể thấy rằng việc vượt quá đối với mã / lex / trình phân tích cú pháp được tạo ra khá dễ dàng.

Nếu các giới hạn này bị vượt quá, bạn có hành vi không xác định (sự cố, lỗi bảo mật, v.v ...).

Phải, tôi biết đây là từ đặc tả C, nhưng C ++ chia sẻ những hỗ trợ cơ bản này.

Sử dụng memcpyđể sao chép giữa các vùng bộ nhớ chồng chéo. Ví dụ:

char a[256] = {};
memcpy(a, a, sizeof(a));

Hành vi không được xác định theo Tiêu chuẩn C, được áp dụng theo Tiêu chuẩn C ++ 03.

7.21.2.1 Hàm memcpy

Tóm tắc

1 / #include void * memcpy (void * hạn chế s1, const void * hạn chế s2, size_t n);

Sự miêu tả

2 / Hàm memcpy sao chép n ký tự từ đối tượng được trỏ bởi s2 vào đối tượng được trỏ bởi s1. Nếu sao chép diễn ra giữa các đối tượng chồng lấp, hành vi không được xác định. Trả về 3 Hàm memcpy trả về giá trị của s1.

7.21.2.2 Hàm memmove

Tóm tắc

1 #incolee void * memmove (void * s1, const void * s2, size_t n);

Sự miêu tả

2 Hàm memmove sao chép n ký tự từ đối tượng được trỏ bởi s2 vào đối tượng được trỏ bởi s1. Việc sao chép diễn ra như thể các ký tự n từ đối tượng được trỏ bởi s2 trước tiên được sao chép vào một mảng tạm thời của n ký tự không trùng với các đối tượng được trỏ bởi s1 và s2, sau đó các ký tự n từ mảng tạm thời được sao chép vào đối tượng được chỉ bởi s1. Trả về

3 Hàm memmove trả về giá trị của s1.

Loại duy nhất mà C ++ đảm bảo kích thước là char. Và kích thước là 1. Kích thước của tất cả các loại khác phụ thuộc vào nền tảng.

Các đối tượng mức không gian tên trong một đơn vị biên dịch khác nhau không bao giờ nên phụ thuộc vào nhau để khởi tạo, vì thứ tự khởi tạo của chúng không được xác định.