In C, Can two false (zero) be together?

I know that the operator only works if it evaluates to true by any means such as OR/AND

.

I don't understand why computers can't figure this out well, at least in C ++.

#include <stdio.h>
#include <stdbool.h>

int main(void) {
    // your code goes here
    if(false && false)
        printf("true\n");
    else
        printf("false\n");
    return 0;
}

      

        
        
        
      

    

Output: false

I know that by looking at this code, you can quickly see that 2 is fake and it will be fake.

But what if they both became fake together because the AND operator doesn't make them true? not trying to the operator NOT

here, just don't understand why the 2 false ones checked together and both give the same result, don't they do true?

Now that I've written more about this, it looks like it will break a lot of programs hehe ..

I guess I just thought of a different way of thinking for a second of a second and I didn't understand why it didn't work.

EDIT: yaa I think I am getting a bunch of downvotes. I guess it's just how computers were built, they don't have real logic.

EDIT 2:

Ok I'll give you an example

Say that you need to combine the package of packages so as not to spam too many small packages. But there is a catch, if these small packets are too big, you cannot combine them, just send them as they are. But suppose you have already started combining packets, and there is a large packet in the process, so you cannot proceed further, you must exit and send the current combo packet.

The problem arises when exiting the batch loop in the list.

I am trying to avoid having 2 loops to check the list in expanded state to know what to do, trying to make it as optimized as possible is very important to me.

So I ended up in the program

if(already building a combined packet boolean   AND    current_packet->size > MAX_COMBINE_PACKET)
  break;
else
  //don't try to combine the packets just send normally.

      

        
        
        
      

    

So, in this situation, I did not start combining packages, and the size of the package may fit into the merge package.

But in this case, it doesn't matter if the package has already started combining or has not yet started combining, but it can still be combined, it will not try to combine it.

I think I need to split it up into more if statements.

EDIT 3: real code

/* pull packets from packet list into buf, and erase/free them */
static int pull_packets(packet_list_t *l, uint8_t *buf, bool cluster) {
    int bytes_placed = 0;
    int offset = 0;
    bool building_cluster = false;
    int MAX_CLUSTER_SIZE = 0xFF; //maybe make this a constant? 0xFF bytes is the payload max.

    while(l->begin() != l->end()) {
        PACKET *p = *l->begin();
        /* if you are building a cluster and the packet can't be clustered you can't send a regular packet anymore */
        /* otherwise just send it as a regular packet, ignore any clustering */
        if(building_cluster && p->len > MAX_CLUSTER_SIZE) 
            break; 
        else  //else if(!building_cluster && p->len > MAX_CLUSTER_SIZE)
            cluster = false;
        /* if theres room in the packet for cluster+cluster len+[packet] */
        if(cluster && p->len <= (MAX_PACKET - offset)) {
            if(!building_cluster) {
                //starts a new cluster packet 
                bytes_placed = build_packet( buf, "BBBX", 0x00, 0x0e, p->len, p->data, p->len);
                offset += bytes_placed;
                building_cluster = true;
                free_packet(p);
                l->erase(l->begin());
            } else {
                //appends to existing cluster packet
                bytes_placed = build_packet( &buf[offset], "BX", p->len, p->data, p->len);
                offset += bytes_placed;
                free_packet(p);
                l->erase(l->begin());
            }
        } else {
            /* can't create cluster or cluster is filled up */
            if(building_cluster) //has a previous cluster in progress
                break;
            //cluster is filled up
            bytes_placed = build_packet(buf, "X", p->data, p->len);
            free_packet(p);
            l->erase(l->begin());
            return bytes_placed;
        }
    }
    return offset;
}

      

        
        
        
      

    

EDIT 4: finished with

else if(!building_cluster && p->len > MAX_CLUSTER_SIZE)