Shulou(Shulou.com)06/02 Report--

This article will explain in detail the differences between Go language and C language. The editor thinks it is very practical, so I share it with you for reference. I hope you can get something after reading this article.

The grammar of C

First of all, let's look at the syntax of C. C adopts a clever and unusual declaration syntax. When you declare a variable, you simply write an expression with the name of the target variable, and then indicate the type of the expression itself in the expression. For example:

Int x

The above code declares the x variable, and its type is int--, that is, the expression x is of type int. In general, in order to specify the type of new variable, we have to write an expression that contains the variable we want to declare, and the result value of this expression operation belongs to some basic type, which we write to the left of the expression. Therefore, the following statement:

Int * p; int a [3]

Indicates that p is a pointer of type int because the type of * p is int. And an is an int array because the type of a [3] is int (regardless of the index value that appears here, it's just used to indicate the length of the array).

Let's take a look at the function declaration next. The type of parameter in C's function declaration is written outside parentheses, like this:

Int main (argc, argv) int argc; char * argv []; {/ *... * /}

As mentioned earlier, we can see that main is a function because the expression main (argc, argv) returns int. In modern notation, we write like this:

Int main (int argc, char * argv []) {/ *... * /}

Although it looks different, the basic structure is the same.

In general, the syntax of C is smart when the type is simple. Unfortunately, once the type starts to be complex, the syntax of C can quickly become confusing. For famous examples such as function pointers, we have to write as follows:

Int (* fp) (int a, int b)

Here, fp is a pointer because if you write an expression like (* fp) (a, b), it will call a function that returns a value of type int. What if one of the parameters of fp is itself a function?

Int (* fp) (int (* ff) (int x, int y), int b)

This is a bit difficult to read.

Of course, we can declare a function without specifying the name of the parameter, so the main function can be declared as:

Int main (int, char * [])

In retrospect, argv used to look like this

Char * argv []

Did you find that you removed the variable name from the declared "middle" and constructed its variable type? Although this is not obvious, when you declare a variable of type char * [], you need to insert the name in the middle of the variable type.

Let's see what happens if we don't name the parameter of fp:

Int (* fp) (int (*) (int, int), int)

The difficulty of this thing is not only to remember that the parameter name was originally put in the middle.

Int (*) (int, int)

What is even more confusing is that it may not even be clear that this is a function pointer declaration. Let's go on to see what happens if the return value is also a function pointer type.

Int (* (* fp) (int (*) (int, int), int) (int, int)

It's hard to see that this is a statement about fp.

You can build more complex examples yourself, but this is enough to explain some of the complexities introduced by C's declaration syntax.

It is also important to point out that because type syntax is the same as declaration syntax, it may be difficult to parse expressions with types in the middle. That's why C always encloses types in parentheses when doing type conversions, like this.

(int) the syntax of M_PIGo

Non-C family languages usually use a different type syntax when declaring. The name usually appears first, followed by a colon. If you write like this, the example we gave above will look like this:

X: int p: pointer to int a: array [3] of int

Even if such a statement is a bit lengthy, it should at least be clear-you just need to read it from left to right. The solution adopted by the Go language is based on this, but in pursuit of simplicity, the Go language has lost colons and some keywords, as follows:

X int p * int a [3] int

There is no direct correspondence between the use of an in [3] int and the expression (we will return to the issue of pointers in the next section). At this point, you have achieved an improvement in code clarity, but at the cost of syntax discrimination.

Let's consider the problem of functions. Although in the Go language, the main function actually has no arguments, let's first copy the previous declaration of the main function:

Func main (argc int, argv * [] byte) int

At first glance, it's no different from C, but it's good to read from left to right.

The main function takes an int and a pointer and returns an int.

If the parameter name is removed at this time, it is still clear-- because the parameter name always comes before the type, it will not cause confusion.

Func main (int, * [] byte) int

One value of this left-to-right style declaration is that as the type becomes more complex, it is still relatively simple. The following is a declaration of a function variable (equivalent to a function pointer in C language)

F func (func (int,int) int,int) int

Or when it returns a function:

F func (func (int,int) int,int) func (int,int) int

The above declaration is still clear, from left to right, and it is easy to understand which variable name is currently declared-because the variable name is always in the first place.

The difference between type syntax and expression syntax makes it easier to invoke closures in the Go language:

Sum: = func (a, b int) int {return aquib} (3,4) pointer

There are some exceptions to the pointer. Notice that in arrays (array) and slices (slice), Go's type syntax places square brackets to the left of the type, but in expression syntax it puts square brackets to the right:

Var a [] int x = a [1]

Similarly, the pointer to Go follows the C * notation, but when we write it, we declare * to the right of the variable name, but we have to put * to the left and left in the expression:

Var p * int x = * p

It can't be written like this.

Var p * int x = p *

Because the suffix * may be confused with multiplication, maybe we can use the ^ tag of Pascal instead, like this

Var p ^ int x = p ^

Maybe we should really change * to ^ like above (of course, we have to change the symbol of the xor operation as well), because the * prefix in types and expressions does make some things a little complicated, for example, although we can write like this

[] int ("hi")

However, when converting, if the type begins with *, you have to add parentheses:

(* int) (nil)

If one day we are willing to give up using * as pointer syntax, then the parentheses above can be omitted.

It can be seen that the pointer syntax of Go is similar to that of C. But this similarity also means that we cannot completely avoid situations where parentheses are sometimes needed in grammar to avoid ambiguity between types and expressions.

This is the end of the article on "what are the differences between Go and C". I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, please share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.