Why is it that computers have a language called C and not a b?

Computers have A and B languages, but they are only early versions of C and are not very useful, and Che is only used by early scientists, and most people don't know much about it.

a>b！=c means that a and b are compared first, and then the value of the expression a>b is not equal to the expression of c.

Break back, and then get the result of the answer expression.

For example: when a=2, b=1, c=1. The execution process of the statement is as follows:

Execute a>b first, because a=2, b=1, so a>b is converted to 2>1, and the result of the execution is 1, because in c language non-0 is 1. Then judge 1! =1, because 1=1, the result of the expression is 0, which is the execution flow of the statement.

a>b returns the logical bool value, compares the comparison result of a>b with the value of c, and returns the comparison result again.

It seems that the two expressions you give are only ...... difference between Chinese parentheses and English parentheses

Friend, > is a comparison operator,! = is a logical operator! Its priority is lower than that of the comparison operator, so first determine whether a>b are specialized.

If it is true, then it is 1 if it is a>b whole, and 0 if it is not true, and then judge whether a>b is equal to c, and if it is not equal to a>b!The formula =c is 1 as a whole, and if it is equal to c, then a>b!=c

This equation as a whole is 0It should be used to determine whether the value of c is 1 or 0.

First determine whether a>b is true, if so, then a>b is 1 as a whole, and 0 if it is not true, and then judge whether a>b is equal to c, if not a>b!The formula =c is 1 as a whole, and if it is equal to c, then a>b!=c is 0

Typical Chinese education... Who would write that in **?

It should be used to determine whether the value of c is 1 or 0.

A&B in C means that A and B are bitwise and arithmetic. & is followed by a variable. Each variable corresponds to a piece of storage space.

Each storage space has a number, that is, the address, & variable name, which means that the number is taken out, and the variable name represents the value in the storage space corresponding to the number. There are only 32 keywords and 9 control statements in the C language, and the program is written freely, mainly represented by lowercase letters. It combines the basic structure and sentences of a high-level language with the usefulness of a low-level language.

C can manipulate bits, bytes, and addresses in the same way as assembly language, which are the most basic units of work of a computer.

means division, a and b are integers, so a b is calculated as an integer.

C Language Operator:

Logical non-operators.

Bitwise inverts the caller operator.

Autoincrement operator.

Self-decrement operator.

Negative operator.

Type) type conversion operator.

Pointer operator.

Addresses and operators.

sizeoflength operator.

Expand the information of the Zen sideCharacteristics of the C language.

1. In the standard C documentation, there is no very clear explanation of the binding nature of operators. A perfect score: it's the arbiter, deciding which one to execute first when several operators have the same priority.

2. The C language also stipulates different combinations of 34 operators. Most operators combine in the direction of "left to right", i.e., left first and then right, also called "left binding", for example, a b+c, there are two operators in the expression, and the + operator has the same priority.

3. There are three types of operators in the C language, which are from the right to the left of the sum faction, also known as the "right combination", namely: monocular operators, conditional operators, and assignment operators.

First, the meaning of the expression is different.

1、(a>b)?a:b: If A is greater than B, then take A, otherwise take B.

2. (a) Second, the logical order is different.

Third, the order of execution is different.

1、(a>b)?a:b: takes the maximum value between a and b.

c, "(a>b)?".The difference between "a:b" and "(a" is that when a and b are equal, the value of the former is b, and the value of the latter is a.

The expression for the conditional operator is "Expression 1? Expression 2: Expression 3", first solve expression 1, if its value is true (not 0), then the value of expression 2 will be the value of the whole expression, otherwise (the value of expression 1 is 0), the value of expression 3 will be the value of the whole expression.

For example: 1, max=(a>b)?a:b

It is to assign the greater of a and b to Max.

2. min=(a is to assign the smaller of a and b to min.)

1. Essential differences.

Double quotes are strings, while single quotes represent characters.

2. Output difference.

str = "a" outputs the letter a;

str = 'a' output of test 65

3. The difference between the bottom layers.

A character enclosed in single quotes actually represents an integer, and the integer value corresponds to the sequence value of that character in the character set adopted by the compiler.

The first one executes A if A>B is true, and if it is false, executes B

The second ifIf < B is true, it will execute B, and if it is false, it will execute A, and that's it.

This has nothing to do with (), I'll talk about it in detail, you must read it :) Pay attention to understand the difference between A++ and ++A:

a++: Substitute the value of a into the expression first, and then ++ after the expression is analyzed.

A: Perform ++ processing of A first, and then substitute the value of A into the expressionNote that for A++, there is a "After the expression is completed, then A is ++ processed", b=(a++) This is an assignment expression, so first substitute the value of A into the expression, you must wait until the assignment expression is completed, and then ++ process A, that is to say, you must wait until B is assigned a value, and then ++ processing A, so B=3, A=4

> c is equivalent to a=(b>c) is an assignment expression that assigns the value of (b>c) to a, (1) if b>c is true, then assign 1 to a, and 2) if b>c is false, assign 0 to a.

3) After running the expression, only the value of a changes, and the values of b and c remain unchanged.

c is also equivalent to a==(b>c) is a consistent expression, first judge the truth of (b>c), 1) if it is true, a is 1, then the expression is true, that is, the value of the consistent expression is 1.

2) If it is true and a is not 1, then the expression is false, that is, the value of the expression is 0.

3) If it is false, a is 0, then the expression is true, that is, the value of the expression is 1.

4) If it is false, a is not 0, then the expression is false, that is, the value that matches the expression is 0.

5) After running the expression, the values of a, b, and c do not change.

The delimiter is different, the character constant uses a single straight skimming, and the string constant uses double quotation mark length, the character constant can only have one character, that is to say, the character constant length is one, and the string constant can be 0 or any number. Even if the string constant has one number of characters, the length is not one.

For example, string constants"h"(This phone doesn't have double quotes).

If the length is 2, the character is h 0

A is one dimension less than A, and I'll explain it to you specifically.

Several elements can form an array, and several one-dimensional arrays can form a two-dimensional array, and so on all the time.

For example, a[0]=2, a[1]=1, a[2]=3, to form a one-dimensional array, this is aHowever, you should note that A does not store all these things directly, A only stores the first address.

Suppose a two-dimensional array a[3][3].At this point, a[0], a[1], and a[2] are no longer elements, but represent a one-bit array with three elements, and a is a two-dimensional array. If you feel that this is a little difficult, it doesn't matter, and after learning the pointer or something, you will understand this very well for a long time.

Let's talk about the program you gave, are you wondering why gets() just gives str1 is fine? And that output function, why just give str1?

This has to be related to the storage method, the string is a two-dimensional array of characters, gets() needs to enter the first address of the string, this is easy to understand, because you should have learned scanf(), the two are about the same, the key is why the output function directly wrote str1? Before printf(), what you learned was generally (printf("%d", a[1])) of this type. Why do we need to fill in an address parameter here?

This is because you are in front of %s s for the string, and the string itself is two-dimensional, so of course, you can't just give him a single element, so how do you know what your string is when you give the first address? Because strings are stored sequentially, and more importantly, strings have a flag "0" at the end, so you just give him the first address, and he will know that he starts with ** and ends with **.

&aaddress: *p, there's nothing to say.

int *p; int a;

The address of a is 1000h, i.e. &a == 1000hp is the pointer, it itself also has an address to store it, set 1200h, that is&p == 1200h (under win32, the pointer itself is 32 bits long, that is, 4 bytes, can be obtained by sizeof(p)).This means that two blocks of memory are used.

p = &a;i.e. p == 1000hThis is an address value, which is essentially a value, that is, it can be added or subtracted. But after addition and subtraction, p, *p may be inaccessible, because it no longer points to a, for example, p == 1004h, if this is operated in a certain function, and the 1004h address is not in the address space of this program, when taking *p, it will be illegally accessed, and it will crash; But if the 1004h address happens to be another int b in this function; The address of the variable, then the value of *p is b.

p indicates the value of P pointing to the address, that is, the value on 1000h; a = 1;The value on 1000h is 1, so *p == 1;a, it is just a symbol itself, this symbol represents an int type length (4 bytes) of the address from 1000h, a=1, that is, the memory block puts a value of 1, if there is an assembly idea, it can be more vivid: [1000h] = 1, there is no need for a, b, c....and so on, directly accessing the memory address.

A and p are variables, &a and *p are expressions, 1 and 0x1000 are constants a and *p represent integer lvalues, p and &a represent pointer lvalues, and 1 and 0x1000 represent integer and pointer rvalues. (If you don't know the concept of left and right values, google it).

In memory, a and p have storage space, a stores 1, p stores 0x1000, *p and &a have no space, and their results are stored in registers, and 1 and 0x1000 also have space, which is stored in the constant section of the program.

According to Stanley Lippman's book "C++ Primer", p is a pointer variable, * is a dereference operator, and *p is an expression that means "dereference the pointer variable p", which is exactly the opposite of the expression &a, which is the opposite of the expression &a, which is the address of the integer variable a.

First, let's make it clear that a is a variable, and the hypothetical definition is int a;

Again, make sure p is a pointer, assuming that it is defined as int* p;

When we define a a, the system will allocate a memory for you to use to store its value, e.g. executed a=10;After this memory stores a number of 10, when we want to use the 10 it represents, we can directly replace it with a.

Now let's use p=&a"&"Called the address character, it is an operator. "&a"It means that pointing to a is the address of the memory with 10 above. What if we use a and it's clear that we can't just use p because it's an address and not the number 10 we need?

We're available here"*"This symbol, which means to take the data in memory that this pointer refers to, i.e. *p means a usage or something is the same.

First, first determine whether b>c is true, and if so, assign 1 to a, otherwise 0 to a

Second, first determine whether b>c is true, if it is true, compare 1 with a, if a=1, then the whole expression is 1, otherwise the whole expression is 0.

If a, b are both integers. a b is the quotient and a%b is the remainder.

If a and b are floating-point floats, this is the result of the calculation.