In C, Can two false (zero)'s be true together? [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 8 years ago.
Improve this question
I know that a statement only works if the it evaluates to true by any means such as OR/AND.
I don't understand why computers can't understand this well at least 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 looking at that code you quickly see that 2 falses and it will be false.
But what if they both became false together as a AND operator doesn't that make them true? not trying to the NOT operator here just don't understand why 2 false's checked together and both give the same output don't make a true?
Now that I wrote more about this seems like it would break alot of programs hehe..
I guess I just wondered into a different way of thinking for a split second and I didn't understand why it didn't work that way.
EDIT: yaa i guess i'll be receiving a bunch of downvotes I guess it's just simply how computers were built they don't have real logic
EDIT 2:
Okay I'll give you a example
Say you have to combine a bunch of packets together not to spam too much little packets.
But there is a catch if those small packets are too large you won't be able to combine them at all just send them as they are.
But lets say you already started combining packets and in the process a large packet arrises so you can't possiblely go on any further you have to quit here and send the current combined packet.
The problem arrises when to break out of the loop of packets in the list..
I am trying to avoid having 2 loops to check the list in advanced to know what to do trying to make it as optimized as possible very important to me.
So I got into a 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 haven't started combining packets and the packet size can fit into a combine packet.
But in this case it doesn't matter if the packet already started combining or hasn't started combining yet but still can be combined it will not try to combine it..
I guess I need to split it up into more if statements.
EDIT 3: the 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: ended up using
else if(!building_cluster && p->len > MAX_CLUSTER_SIZE)

Answer 1

I think you are probably confusing false && false with double negation. While double negation becomes affirmative, the way this is expressed in C and C++ is !false or !0.
Your problem description and code is a little vague, but assuming what you really want is:
if not in a combined packet but the current packet is too big,then send the current
if in a combined packet but the current packet is too big,then send the combined, then send the current
if not in a combined packet, but the current packet is small,then break to do the combine
if in a combined packet but the current packet is small,then break to do the combine
Assuming the above is correct, then you only have to check to see if your current packet is small and will fit, otherwise you need to forward stuff.
Looking at your real code, there seems to be some confusing logic around whether you are currently building a cluster, and whether the current packet will fit into your cluster. You will benefit from following a simplified structure. The following pseudocode roughly follows what I had originally suggested, but tailored around how your loop actually operates.
bool start = true;
while (packet = head of list of packets) {
if (packet will fit cluster) {
if (start) {
initialize cluster with packet;
start = false;
} else {
add packet to cluster;
}
remove from head;
} else {
if (start) {
initialize cluster with XL packet;
remove from head;
}
break;
}
}

Answer 2

The logical and has the following value table:
true && true => true
true && false => false
false && true => false
false && false => false
The result is only true if both operands are true. That's just the way it is. That is the real logic. If you don't believe me, just read the Wiki article on boolean algebra. It defines 'and' as above.
If you want a condition that evaluates to true if both operands are of the same value (e.g. both true or both false) then you can just use if(a == b) ..

Answer 3

The && operation is not about agreement.
The false values here are not about negation.
The false values here are values.
The && operation is a function, defined such that true && true yeilds true and any other combination yeilds a value false.
In short a && b is shorthand for
a && b = f(a, b)
where
f(a, b) = { false | a = false, b = false
{ false | a = true, b = false
{ false | a = false, b = true
{ true | a = true, b = true
&& is a computer operation that represents a boolean and operation. It is formally defined within boolean number systems, and typically studied with boolean logic.

Answer 4

This is not about that kind of logic. It's about processing logic. In programming languages, when you have something like:
if (false && false) { ... }
The compiler sees options inside your if because of the &&. Then it evaluates the fisrt one, which is false. From that point, there's no point on evaluating the next expression - since the first one evaluates to false, there's no need to evaluate whatever follows &&, because that's an automatic whole false: false &&.
That's why the following is true:
true && true => true
true && false => false
false && true => false
false && false => false
...which, the way the compiler sees it (as in where it stops evaluating) is:
true && true => true
true && false => false
false && [THIS IS NOT EVEN EVALUATED] => false
false && [THIS IS NOT EVEN EVALUATED] => false

Answer 5

Check out this "truth table":
http://en.wikipedia.org/wiki/Truth_table#Truth_table_for_all_binary_logical_operators
The operation you're looking for is probably "exclusive NOR", which is the "NOT" of "exclusive OR". Exclusive OR is represented by a circle with a + in it in mathematics, and, when used for bitwise computations, by the ^ symbol in C-based languages. For "logical" computations exclusive OR can be represented by the "not equals" operator (and "exclusive NOR" is the "equals" operator).