Hi~ I'm Anka!

A basic C program#

1
#include <stdio.h>
2
int main() {
3
    puts(“Hello World!\n”);
4
    return 0;
5
}

.h header
.c
.lib

#include in C resembles import in Java or Python, except that the imported material is a header file; what this means will be discussed later.
C中的#include类似于Java或Python中的import，不同之处在于导入的材料是头文件；这意味着什么将在后面讨论。
The angle brackets <> tell C to search for the stdio.h file in the compiler’s standard libraries.
尖括号<>告诉C在编译器的标准库中搜索stdio.h文件。
Using quotes "" is legal but tells C that the file should be in the same directory.
使用引号""是合法的，但会告诉C文件应该在同一个目录中。

C is not object oriented, and in C++ object orientation is not mandatory as it is in Java.
You do not have to define classes (in C you cannot) and your main “method” must not be in a class (and is thus a function, not a method). C不是面向对象的，在C++中，面向对象也不像在Java中那样是强制性的。 你不必定义类（在C中你不能），你的main“方法”不能在类中（因此是一个函数，而不是一个方法）。

The syntax for defining a function is the same as a method in Java but without the access specifier (public/private etc.) since these don’t apply to functions.
The main function is the main program. It returns an int, which is returned to the operating system. 定义函数的语法与Java中的方法相同，但没有访问说明符（public / private等），因为这些不适用于函数。 main函数是主程序。它返回一个int，并返回给操作系统。

puts is the C function to output a string. (It’s part of stdio, that’s why we imported it.)
\n at the end of the string represents the byte sent to the OS to tell it to move to the next line.
puts是用于输出字符串的C函数。（这是stdio的一部分，所以我们才导入它。） 字符串末尾的\n表示发送给操作系统的字节，以告诉它移动到下一行。

The same in C++#

1
#include <iostream>
2
using std::cout;
3
using std::endl;
4
int main() {
5
    cout << “Hello World!” << endl;
6
    return 0;
7
}

打印： put
printf
cout<< (C++)

in C：function （no class）
in C++：function、member function

A simple loop#

1
#include <stdio.h>
2
#include <stdint.h>
3
int main() {
4
    for (uint8_t x=0; x<10; x++) {
5
        printf(“%i\n”,x);
6
    }
7
    return 0;
8
}

1
#include <iostream>
2
using namespace std;
3
    int main() {
4
        for (uint8_t x=0; x<10; x++) {
5
        cout << +x << endl;
6
    }
7
    return 0;
8
}

Pay more attention on type
uint8: unsigned integer 8bits

1
#include <stdio.h>
2
#include <stdint.h>
3

4
int main() {
5
  for (uint8_t x=0; x<10; x++) {
6
    printf(“%i\n”,x);
7
  }
8
  return 0;
9
}

Looking at the for loop:

1
//c:line-numbers=5
2
  for (uint8_t x=0; x<10; x++) {
3
    printf(“%i\n”,x);
4
  }

As mentioned before, the for syntax in C and C++ is identical to Java. (Java copied it from C++!)
如前所述，C和C++中的for语法与Java相同。（Java从C++中复制了它！）
The printf (print formatted) function is used to print out strings containing numbers or other material.
printf（打印格式化）函数用于打印包含数字或其他材料的字符串。
Also note the type declaration is unusual. 还要注意类型声明是不寻常的。

Type declarations in C#

• In the original C, the types used were the same as in Java – int, float, etc.
• 在最初的C语言中，使用的类型与Java中相同- int, float等。
• However, unlike Java, C compiles right down to machine code – and different computers have different abilities to handle numbers in machine code.
• 然而，与Java不同的是，C直接编译成机器码——不同的计算机处理机器码中的数字的能力也不同。
• This caused confusion with int meaning different things and having different properties based on the machine being compiled on. As a result, in 1999 the types were respecified to allow the programmer to specify exactly how the computer should store the number.
• 这引起了int的混淆，因为int意味着不同的东西，并且根据编译的机器具有不同的属性。因此，在1999年，这些类型被重新指定，以允许程序员指定计算机应该如何存储数字。

Integer standard types#

• Modern processors can handle up to 32-bit numbers in single machine code instructions. Many can handle 64-bit numbers.
• 现代处理器可以在单个机器代码指令中处理多达32位的数字。许多可以处理64位数字。
• However, smaller embedded systems may only be able to deal with 16-bit or even 8-bit numbers directly in their machine code.
• 然而，较小的嵌入式系统可能只能在其机器码中直接处理16位甚至8位数字。
• Managing larger numbers on these systems requires the compiler to include extra code to transfer carry, etc, information between parts of the number.
• 在这些系统上管理较大的数字需要编译器包含额外的代码来在数字的各个部分之间传递进位等信息。

Relative types#

(U)Int_leastX_t: declares the variable must have at least X bits but may have more. This is used to allow for systems with machine code that may no longer handle smaller numbers.
(U)Int_leastX_t：声明变量必须至少有X位，但可以有更多。这是用来允许系统的机器码可能不再处理较小的数字。

(U)Int_fastX_t: declares the variable must have at least X bits and should be “fast” on the platform being used. The precise meaning of this is not defined but compilers are supposed to select a type native to the CPU’s code. ---Rarely used.
(U)Int_fastX_t：声明变量必须至少有X位，并且在使用的平台上应该是“快速的”。它的确切含义没有定义，但编译器应该选择CPU代码的本机类型。——很少使用。

Printf#

In Python:

1
print("You have",dogs,"dogs and",cats,"cats.")

In C:

1
printf("You have %i dogs and %icats.\n",dogs,cats);

• The first parameter (called the format string) gives the overall structure of what you want to print.
• 第一个参数（称为格式字符串）给出了要打印的内容的总体结构。
• You add “slots” into it with %i (or other markers we’ll see later), then fill them in.
• 您可以使用%i（或我们稍后将看到的其他标记）在其中添加“插槽”，然后填充它们。

The loop in C++#

1
//cpp:line-numbers
2
#include <iostream>
3
using namespace std;
4

5
int main() {
6
  for (uint8_t x=0; x<10; x++) {
7
    cout << +x << endl;
8
  }
9
return 0;
10
}

The code is mostly the same as in C except we are using the iostream facilities C++ provides.
除了使用C++提供的iostream功能外，代码与C中的代码基本相同。
This is cleaner than printf:
这比printf更干净：

1
cout << "You have " << dogs << " dogs and " << cats << " cats." << endl;

1
#include <iostream>
2
using namespace std;
3

4
int main() {
5
  for (uint8_t x=0; x<10; x++) {
6
  cout << +x << endl;
7
  }
8
return 0;
9
}

However, note the + before x. This is because, without the specific information printf gives, C++ has to assume what format to use to print the contents of the variable. In the case of an 8-bit integer, by default, it assumes wrong! (It’s ok for larger integers though…)
但是，请注意x之前的+。这是因为，由于没有printf提供的特定信息，C++必须假定使用什么格式来打印变量的内容。在8位整数的情况下，默认情况下，它假定错误！（对于较大的整数是可以的…）

A test, please run this line and see the result:

1
#include <iostream>
2
using namespace std;
3

4
int main() {
5
for (uint8_t x=0; x<2; x++) {
6
  cout << +x << endl;
7
  cout<<-x<<endl;
8
  cout<<x<<endl;
9
  }
10

11
cout<<sizeof(int)<<endl;
12
cout<<sizeof(uint16_t );
13

14
return 0;
15
}

::: details See the output The output is:

1
0
2
0
3
null
4
1
5
-1
6
null
7
4
8
2

:::

Input#

1
int main() {
2
    int32_t age;
3
    puts(“How old are you?”);
4
    scanf(“%i”,&age);
5
    printf(“You typed %i.\n”,age);
6
    if (age > 18) {
7
        puts(“You can vote.”);
8
    }
9
    return 0;
10
}

scanf() getline()

1
int main() {
2
  uint16_t age;
3
  cout << “How old are you?”;
4
  cin >> age;
5
  cout << “You typed” << age <<
6
  endl;
7
  if (age > 18) {
8
    cout << “You can vote.”;
9
  }
10
return 0;
11
}

Conversion Specifiers in C#