如何比较结构中不同索引的元素

How can I compare elements from different indexes in struct

本文关键字：索引 元素 结构 何比较 比较      更新时间：2023-10-16
#include<iostream>
using namespace std;
struct workspace {
    int ID;
    int price;
    int incoming_amount;
    int outgoing_amount;
    int date;
};
int main ()
{
    workspace works[5];
    string type_amount;
    int incoming_IDs[5];
    int incoming_IDs_counter = 0;
    for(int i = 0; i < 5; i++){
        cin >> works[i].ID;
        cin >> works[i].price;
        cout << "What type of amount (inc/out)?" << endl;
        cin >> type_amount;
        if(type_amount == "inc"){
            incoming_IDs[incoming_IDs_counter] = works[i].ID;
            incoming_IDs_counter++;
            works[i].outgoing_amount = 0;
            cin >> works[i].incoming_amount;
        }
        else if(type_amount == "out"){
            works[i].incoming_amount = 0;
            cin >> works[i].outgoing_amount;
        }
        cin >> works[i].date;
    }
    return 0;
}

这是我到目前为止的代码，现在我必须检查以下内容：

  • 确保 ID 添加了传入金额，然后才能成为传出金额。

    • 如果传入金额

  • 低于传出金额，请确保传入金额的价格。

所以，我

做了第一个，我得到了这个功能：

bool INC_Exists(workspace &works, int &incoming_IDs_counter, int incoming_IDs[]){
    for(int i = 0; i < incoming_IDs_counter; i++){
        if(incoming_IDs[i] == works.ID){
            return true;
            break;
        }
    }
    return false;
}

它似乎有效并完成了工作，但对于第二个，我不知道如何解决。如何有效地检查传出金额的价格是否小于同一 ID 的传入金额？

bool Valid_Price(workspace *works, int& incoming_IDs_counter, int incoming_IDs[], workspace &workz){
    bool valid_price;
    for(int j = 0; j < incoming_IDs_counter; j++){
        if(incoming_IDs[j] == workz.ID){
            for(int k = 0; k < 5; k++){
                if(works[k].ID == workz.ID){
                    if(works[k].price < workz.price){
                        valid_price = true;
                    }
                    else if(works[k].price > workz.price){
                        valid_price = false;
                    }
                }
            }
        }
    }
    return valid_price;
}

经过测试，似乎有效..

bool Valid_Price(workspace *works, int& incoming_IDs_counter, int incoming_IDs[], workspace &workz){
    for(int i = 0; i < 5; i++){
        for(int j = 0; j < incoming_IDs_counter; j++){
            if(incoming_IDs[j] == workz.ID){
                for(int k = 0; k < 5; k++){
                    if(works[k].price < workz.price){
                        return true;
                    }
                    else{
                        return false;
                    }
                }
            }
        }
    }
}

在第二部分中尝试此代码。

此函数

bool INC_Exists(workspace &works, int &incoming_IDs_counter, int incoming_IDs[]){
    for(int i = 0; i < incoming_IDs_counter; i++){
        if(incoming_IDs[i] == works.sifra){
            return true;
            break;
        }
    }
    return false;
}

无效，因为结构工作区没有数据成员 SIFRA，

如果我正确理解了要求

•确保 ID 已添加传入金额，然后才能添加 传出金额

您需要检查对象是否在 int incoming_IDs[] 的元素中工作。该函数可能如下所示

bool INC_Exists( const int incoming_IDs[], int incoming_IDs_counter,  const workspace &works )
{
    int i = 0;
    while ( i < incoming_IDs_counter && works.ID != incoming_IDs[ i ] ) i++; 
    return ( i != incoming_IDs_counter );
}

至于这个条件

•确保传入金额的价格小于传入金额 量

那么它可以用表达式表示

works.price < works. outgoing_amount

但我不知道这个条件必须在哪里使用。从你的描述来看，这是完全不清楚的。

相关文章：