Cảnh báo biên dịch cho mảng hỗn hợp và đa hình

Question

Trong hiệu quả hơn C++, một điểm thú vị được đưa ra là sự pha trộn của mảng và đa hình là một ý tưởng tồi. Đối với ví dụ:

class Base { 
    public: 
    Base(int y) : a(y) {} 
    int a; 
}; 

class D : public Base { 
    public: 
    D(int w, int y) : Base(y), c(w) {} 
    int c; 
}; 

std::ostream& operator<<(std::ostream& os, const Base &obj) 
{ 
    os << obj.a << std::endl; 
    return os; 
} 

// This function will work perfectly well if i pass in a `Base` array, 
// but if i pass in `D` array we are going to run into some problems. 
// Namely that `arr[i+1] = &arr[i] + sizeof(Base)` will not progress 
// the array correctly for a `D` array. 
void printArray(const Base arr[]) { 
    for (int i = 0; i < 5; ++i) { 
     std::cout << arr[i]; 
    } 
} 

int main() { 
    D arr[5] = { D(0, 10), D(1, 11), D(2, 12), D(3, 13), D(4, 14)}; 
    printArray(arr); // This compiles without complaint! I understand that the 
        // conversion is legal, but it seems like a warning 
        // about this would be a good idea. 
} 

Lưu ý: Tôi biết đây là thiết kế xấu nhưng là để minh họa cho một điểm. Vấn đề ở đây là khi trộn hai cái này theo cách tôi có ở trên, khi chúng ta lặp qua mảng để in, chúng ta sẽ không tiến hành phần tử của mảng theo đúng số lượng (tức là chúng ta di chuyển bởi sizeof(Base) thay vì sizeof(D)). Điều này dẫn đến kết quả:

10 
0 
11 
1 
12 

[Live example.]

(Và tôi đang đoán rằng gọi operator<< như thế này có lẽ là UB).

Khi biên dịch với g++ -std=c++1y -Wall -Weffc++ -pedantic main.cpp Tôi không nhận được cảnh báo hoặc lỗi.

1. Có cờ trình biên dịch mà tôi có thể bật cho biết cảnh báo trong trường hợp này không?
2. Nếu không, tại sao không?

Answer 1

void printArray(const Base arr[]) tương đương với void printArray(const Base* arr).

Đó là hợp pháp để chuyển con trỏ thuộc loại D đến hàm có tham số thuộc loại const Base*. Vì vậy trình biên dịch sẽ không đưa ra bất kỳ cảnh báo nào.

Answer 2

FYI, pha trộn các mảng và đa hình có thể được thực hiện nếu đa hình được cung cấp như một chi tiết thi hành một lớp xử lý:

#include <iostream> 
#include <vector> 

// a handle which will happily own any class which implements the concept 
struct Thing 
{ 
    struct concept 
    { 
     virtual void sayHello() const = 0; 
     virtual ~concept() = default; 
    }; 

    Thing(std::unique_ptr<concept> ptr) : _impl(std::move(ptr)) {} 

    void sayHello() const { _impl->sayHello(); } 

    std::unique_ptr<concept> _impl; 
}; 

struct thing_a : Thing::concept 
{ 
    void sayHello() const override { std::cout << "hello from A\n"; } 
}; 

struct thing_b : Thing::concept 
{ 
    void sayHello() const override { std::cout << "hello from B\n"; } 
}; 

int main() 
{ 
    std::vector<Thing> things; 

    things.emplace_back(std::make_unique<thing_a>()); 
    things.emplace_back(std::make_unique<thing_b>()); 

    for (const auto& t : things) { t.sayHello(); } 
} 

đầu ra mong đợi:

hello from A 
hello from B 

Answer 3

Một trình biên dịch có thể làm được rất nhiều phân tích tĩnh và có thể biết rằng con trỏ arr trong hàm được sử dụng làm mảng có kết quả không mong muốn. Tuy nhiên, làm chậm và sử dụng nhiều bộ nhớ hơn, và các lập trình viên nói chung thiếu kiên nhẫn và muốn biên dịch của họ được thực hiện càng nhanh càng tốt bằng cách sử dụng càng ít tài nguyên càng tốt. Do đó, hầu hết các trình biên dịch chỉ thực hiện các phân tích tĩnh tương đối nhanh chóng và dễ dàng, để lại công việc khó khăn cho các máy phân tích tĩnh chuyên dụng.