Tôi hiện đang theo học lớp lập trình cấp hai ở trường đại học... chúng tôi đang xem xét việc nạp chồng toán tử... mà chúng tôi sẽ xây dựng lại lớp vectơ... Tôi đang xây dựng các lớp và phát hiện ra rằng hầu hết chúng dựa trên [] toán tử. Khi tôi cố gắng thực hiện + toán tử Tôi đã gặp phải một lỗi lạ mà giáo sư của tôi chưa từng thấy trước đây (rõ ràng là do lớp chuyển IDE từ MinGW sang VS express...) (Tôi đang sử dụng phiên bản Visual Studio Express 2008 C++... .)

vector.h

#include 
#include 
using namespace std;

#ifndef _VECTOR_H
#xác định _VECTOR_H

const int DEFAULT_VECTOR_SIZE = 5;

vectơ lớp
{
private:
    dữ liệu int *;
    kích thước int;
    int comp;
public:
    Vector nội tuyến (int Comp = 5, int Size = 0) 
        : comp(Comp), size(Size) { if (comp > 0) { data = new int [comp] } 
                                      khác { dữ liệu = int mới [DEFAULT_VECTOR_SIZE];
                                      comp = DEFAULT_VECTOR_SIZE }
                                    }
    int size_ () const { trả về kích thước }
    int comp_ () const { return comp }
    bool đẩy_back (int);
    bool push_front (int);
    void mở rộng();
    void mở rộng (int);
    khoảng trống rõ ràng();
    chuỗi const tại (int);
    int& toán tử[ ](int);
    int& toán tử[ ](int) const;
    Vector& toán tử+ (Vector&);
    Vector& toán tử- (const Vector&);
    toán tử bool== (const Vector&);
    toán tử bool!= (const Vector&);

    ~Vector() { xóa [] dữ liệu }
};

ostream& toán tử<< (ostream&, const Vector&);

#endif

vector.cpp

#include 
#include 
#include "Vector.h"
using namespace std;

chuỗi const Vector::at(int i) {
    cái này[i];
}

void Vector::expand() {
    mở rộng (kích thước);
}

void Vector::expand(int n ) {
    int * newdata = int mới [comp * 2];
    if (*data != NULL) {
        cho (int i = 0; i <= (comp); i++) {
            newdata[i] = dữ liệu[i];
        }
        dữ liệu mới -= comp;
        comp += n;
        dữ liệu = dữ liệu mới;
    xóa dữ liệu mới;
    }
    khác nếu ( *data == NULL || comp == 0) {
        dữ liệu = int mới [DEFAULT_VECTOR_SIZE];
        comp = DEFAULT_VECTOR_SIZE;
        kích thước = 0;
    }
}

bool Vector::push_back(int n) {
    nếu (comp = 0) { mở rộng();
    cho (int k = 0; k != 2; k++) {
        if (kích thước != comp ){
            dữ liệu[kích thước] = n;
            kích thước++;
            trả về đúng sự thật;
        }
        khác {
            mở rộng();
        }
    }
    trả về sai;
}

void Vector::clear() {
    xóa [] dữ liệu;
    comp = 0;
    kích thước = 0;
}
int& Vector::operator[] (int place) { return (data[place] }
int& Vector::operator[] (int place) const { return (data[place] }

Vector& Vector::operator+ (Vector& n) {
    int temp_int = 0;

    if (size > n.size_() || size == n.size_()) { temp_int = size }
    nếu không thì if (size < n.size_()) { temp_int = n.size_() }

    Vector newone(temp_int);
    int temp_2_int = 0;

    cho (int j = 0; j <= temp_int && 
                     j <= n.size_() && 
                     j <= kích thước; 
                                        j++) {
        temp_2_int = n[j] + dữ liệu[j];
        newone[j] = temp_2_int;
    }
///////////////////////////////////////////////////////////////// //// //////////
    trả lại cái mới;
///////////////////////////////////////////////////////////////// //// //////////
}

ostream& operator<< (ostream& out, const Vector& n) {
    for (int i = 0; i <= n.size_(); i++) {
///////////////////////////////////////////////////////////////// //// //////////
        ra << n[i] << " ";
///////////////////////////////////////////////////////////////// //// //////////
    }
    trở về;
}

sai lầm:

ra << n[i] << " "; lỗi C2678:

Nhị phân '[': Toán tử lấy toán hạng bên trái thuộc loại 'const Vector' không tìm thấy (hoặc không có chuyển đổi được chấp nhận)

trả lại cái mới;

lỗi C2106: '=": toán hạng bên trái phải là giá trị

Như đã đề cập ở trên, tôi đang theo học chuyên ngành khoa học máy tính và tôi muốn nhận được các mẹo, gợi ý và cách thực hiện công việc tốt hơn :D

câu trả lời hay nhất

cái này:

toán tử int[ ](int);

Là một hàm không phải là thành viên const. Điều này có nghĩa là nó không thể ở trong vectơ const trong cuộc gọi.

Thông thường, toán tử chỉ số dưới được triển khai để trả về một tham chiếu (nếu bạn trả về một giá trị, giống như bạn đang làm, bạn không thể sử dụng nó làm giá trị, ví dụ: bạn không thể làm như vậy newone[j] = temp_2_int; Giống như bạn làm trong mã của mình):

int& toán tử[](int);

Để có thể gọi nó trên đối tượng const, bạn cũng nên cung cấp phiên bản const của hàm thành viên:

const int& toán tử[](int) const;

Vì bạn đã yêu cầu "mẹo, hướng dẫn và cách thực hiện tốt hơn:"

• Bạn không thể đặt tên cho người bảo vệ bao gồm của mình _VECTOR_H. Tên bắt đầu bằng dấu gạch dưới, theo sau là chữ in hoa được dành riêng cho việc triển khai. córất nhiều quy tắc về dấu gạch dưới .
• Bạnkhông bao giờđược sử dụng trong tiêu đềsử dụng không gian tên std.
• của bạn toán tử+ nên được thông qua const Vector&, vì nó không sửa đổi các tham số của nó.
• của bạn Tại nên trả lại một int và phải phù hợp với ngữ nghĩa của vùng chứa thư viện chuẩn C++ (tức là nếu Tôi Ngoài phạm vi. Bạn cần sử dụng (*cái này)[i] gọi quá tải toán tử [].
• Những điều bạn cần biết* Vai trò của người vận hành. Ở một số nơi, bạn nhầm lẫn con trỏ với đối tượng mà chúng trỏ tới.
• Lưu ý rằng = Và == sự xáo trộn (ví dụ, trong nếu (comp = 0) ở giữa). trình biên dịch会Cảnh báo bạn về điều này. Đừng bỏ qua các cảnh báo.
• nếu bạn đảm bảo data sẽ không bao giờ là NULL, logic của bạn sẽ đơn giản hơn nhiều.

Về việc nạp chồng toán tử C++ - 'tạo lại Vector', chúng tôi đã tìm thấy một câu hỏi tương tự trên Stack Overflow: https://stackoverflow.com/questions/2567784/