聊聊学习编程语言

学习编程需要什么前提条件

数学和编程的关系

import math
# 使用勾股定理
a = 3
b = 4



     




c = math.pow(a*a + b*b, 1/2)
print('勾', a, '股', b, '弦', c)

语文和编程的关系

常见的判断流程代码

英语和编程的关系

经济条件和编程的关系

C 语言为什么使用如此广泛

操作系统的原生语言

在 Linux 上 man epoll

3L 和 ABI 规范

#include <stdio.h>
int main()
{
   printf("Hello, World!");
   return 0;
}

$ ldd a.out
        linux-vdso.so.1 (0x00007ffc4bfb0000)
        libstdc++.so.6 => /usr/lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007f6b48f24000)
        libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007f6b48c20000)
        libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007f6b48a09000)
        libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f6b4866a000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f6b494ab000)

数学符号关键字

1. 最臭名昭著的数学符号误解，就是=号。在 C 语言中，这个符号实际上对内存的读取和写入操作，但在数学上这是一个“相等”的声明。这导致了大量的因为 if (foo = bar) 的 BUG 诞生。PASCAL 语言用 := 作为赋值符号，可以说是对这种错误的一个纠正。
2. * 号，同时具备“乘法”“声明指针”“解引用”三个含义，具体是什么意思，取决于这个符号写在什么地方。这也是 C 语言代码阅读和学习比较困难的一个原因。

#include <stdio.h>
 
int main ()
{
   int  var = 20;   
   int  *ip;   /* 指针变量的声明，这里的星号表示声明的是一个指针 */
   ip = &var;  


     




/* 等号表示赋值，把 var 的地址写入 ip 变量的内存中 */
 
   /* 使用指针访问值，这里的星号表示“解引用操作符”，即读取指针指向的内存块内容 */
   printf("*ip 变量的值: %d\n", *ip );
   return 0;
}

1. 在数学上，函数可以理解为对某种规律的描述：你可以输入自变量，获得返回值。然而，我们往往把“函数”当成一个功能处理过程去编写，这就导致了“就算相同的输入，也不会有相同的输出”的“函数”的出现。我们表面上好像是用函数在计算一些结果，实际上是利用这些函数的“副作用”去完成一些功能。这种表达和实际的差异，也是造成大量 BUG 的原因。
2. 由于变量对应着内存，所以代码中的变量，并不能单纯的认为是一个数值的容器。譬如在 C 语言中，你如果返回了一个局部变量的指针，这个指针指向的变量内容，很可能在下次使用时，被不知道什么数据所覆盖。所以使用 C 语言必须要理解所谓“堆”和“（堆）栈”的差别。如果你认为局部变量不好用而使用“堆”里的变量，那么就必须注意自己进行内存的回收释放，否则就又掉进了“内存泄漏”的坑里。
3. C 语言中的变量，虽然有各种类型，但实际上编译器几乎不会自动的对其进行什么操作，于是不管是什么类型，其实都代表的一块内存而已。类型不同仅仅是代表不同长度的内存块。而在不同编译器和不同操作系统下，同样的类型对应的长度还不一样，这就更增加了这门语言的复杂性。譬如 32 位系统下的 long int 是 4 个字节，64 位系统下则是 8 个字节。本来这种长度差异不太应该影响程序员编码，但很多 C 的库又设计成使用 指针+长度 的方式来传参，所以变量长度变得不得不关心了。同样的问题还有结构体的字节对齐问题。

自带内存管理的语言们

内存为什么需要管理

Java：你妈觉得你冷

CLASSPATH

内存管理

• 基础类型变量，譬如 int/boolean 这些（注意 String 并不是基础类型），永远都是值传递，你也没法关心是在堆上还是栈上。
• 对象类型变量，所有的 Object 的子类和数组这些，永远都是引用传递（类似指针），所以肯定是在堆上。
• 如果你硬是想弄一个基础类型的数据容器，譬如存放 int 类型的“对象”，那么你需要进行“装箱”这种仪式，幸好新的 JDK 已经从语言层面支持了。

异常机制

FileInputStream in;
try {
  in = new FileInputStream(file);  // 正常流程就这两行
  in.read(filecontent);
} catch (FileNotFoundException e) {
  e.printStackTrace();
} catch (IOException e) {
  e.printStackTrace();
} finally {
  try{
    in.close();
  } catch (IOExeption e) {
    e.printStackTrace();
  }
}

1. NullPointerException 这个异常是由于你调用了一个内容为 null 的对象的方法或者属性。由于 null 这个值非常特殊，它可以被赋值给任何类型的对象，所以很难被简单的发现。什么情况下，一个 Object 变量被赋值为 null 呢？很可能是在调用一个 HashMap 的 get() 方法后，没有判断返回是 null 导致的。有一些 API 调用会返回 null，这个是非常需要注意的。
2. ConcurrentModifyException 如果有两个以上的线程，在同时操作一个容器变量，就可能会出现。譬如一个线程正在用迭代器遍历，另外一个线程在插入元素。大多数情况下解决方法也比较简单，就是用 synchronized 关键字来“锁”住这个容器变量就可以了。当然如果迭代器遍历循环代码里，又调用到另外一个容器的方法，那么就有可能发生“死锁”。当然也可以用一些支持并发的容器，来解决可能的并发修改问题，Java 提供了一整套“并发”所需的库（ java.concurrentcy.* ），包括各种形式的锁、线程安全容器等。

并发支持

C#：我全都要

• Java 不是没有值拷贝的变量类型吗？C# 有，叫 struct
• Java 反对使用“输出参数”，C++ 使用输出参数很普遍，C# 都有，既可以返回一个对象而没有心理负担，也可以用 out/ref 关键字做输出参数。
• 异常处理 try-catch，C# 也有，但不会像 Java 一样强迫你处理
• RTTI、反射，C# 全有
• Java 的 Annotation，C# 叫 Atrribute
• Interface Java 有，C++ 没有，C# 还是有，而且比 Java 的更彻底：要访问一个接口的方法，只能通过接口类型的变量访问，通过真实实现类型的变量是无法通过编译的。
• JavaBean 苦口婆心推广 Setter/Getter 的写法，C# 直接用语言实现掉，就是 Property 特性。
• C++ 可以重载运算符，Java 不可以，所以 C# 也可以自定义+ - * /运算符

Go：专门为服务器端设计的语言

• 所有的源码编译出来就是一个二进制，全部都是静态链接。（在服务器上一般只运行这个程序，也不需要动态更新或者和其他程序共用动态库啥的）
• 包依赖功能自动和 git 绑定，你不喜欢用 git 也不行。（客户端开发，特别是游戏客户端开发，工程里面包含太多二进制文件，用 git 会特别的慢，所以你别用 Go 写客户端吧。）
• 没有什么引用传递，全是值传递，如果不想复制一个巨大的数据块，就用指针。这个指针不能像 C 语言一样进行数学运算 ++ --，但还是要叫“指针”，而不是换成什么别的名字遮掩一下。
• 局部变量返回之后，就变成了堆上的变量，所以也可以垃圾回收了。（不需要手工指定使用堆还是堆栈，就算你用new()指定了，可能也是白忙活）
• 自带并发“协程”，但又不是异步的，一样需要你把容器类型变量锁起来，或者你用线程安全的容器，用起来和多线程几乎一样。
• 把 select、chan 这种东西直接弄到语言里面，尽管这功能完全可以用库的方式提供，但 Go 就是要让你膜拜一下。
• 没有 try-catch-finally 捕捉异常这种玩意，只有 defer 关键字，你就是要用 finally 的写法去干捕捉异常的事情。
• 用注释来生成文档有什么特别的，看我用注释来写程序：go 源码的注释可以写一段 C 语言代码并且调用！

package main

/*
#include <stdio.h>
void c_print(char* str) {
  printf("%s\n", str);
}
*/
import "C"

func main() {
  s := "hello C"
  cs := C.CString(s)
  C.c_print(cs)
}

面向对象语言是一个骗局吗？

OO 三特性

• 封装：历来就有“失血模型”和“充血模型”的争议。在 WEB 开发领域，由于存在大量的数据库 CRUD 操作，所以不管你的类有什么属性，大多数都是那么几个方法，所以把方法和属性封到一块，看起来没啥必要，反而增加了大堆类似而重复的代码。
• 继承：继承会破坏封装，让父类的行为被改变，所以不要继承！用组合来代替继承！多继承是邪恶的，所以只能单继承，如果你需要一个对象同时可以是几个不同的“类型”，那么你只能为这些类型每个都定义一个“接口”，增加一大堆代码。如果“继承树”一开始设计的不合理，极有可能需要修改“树干中”的某一个节点，也就是某个基类，导致下游一大堆的子类被迫要修改。
• 多态：这个特性是争论最小的特性，但是也有人觉得，其实就是一种 switch case 嘛，最高级的程序员（食材）往往只需要最简单的语法（做法）……

类爆炸、构造器混乱和“基于对象”

某种语言的对象构造顺序

C++ 到底是什么？

并不是 C 语言

class Parent {
public:
    int iparent;
    Parent ():iparent (10) {}
    virtual void f() { cout << " Parent::f()" << endl; }
    virtual void g() { cout << " Parent::g()" << endl; }
    virtual void h() { cout << " Parent::h()" << endl; }

};

class Child : public Parent {
public:
    int ichild;
    Child():ichild(100) {}
    virtual void f() { cout << "Child::f()" << endl; }
    virtual void g_child() { cout << "Child::g_child()" << endl; }
    virtual void h_child() { cout << "Child::h_child()" << endl; }
};

class GrandChild : public Child{
public:
    int igrandchild;
    GrandChild():igrandchild(1000) {}
    virtual void f() { cout << "GrandChild::f()" << endl; }
    virtual void g_child() { cout << "GrandChild::g_child()" << endl; }
    virtual void h_grandchild() { cout << "GrandChild::h_grandchild()" << endl; }
};

上面代码一个 GrandChild 对象的内存结构

动态绑定：把指针玩出花儿来

Parent *obj = new Child()

静态绑定：真正的架构师语言

1. 不需要实现 interface，只要“语言签名”对的上，都能直接用
2. 编译时会检查出所有的错误
3. 通过使用泛型类的继承，可以实现对方法调用的“反射”

template <typename T>
void const& DoSomething (T const& a) 
{ 
    a.DoSomething();
} 

编程语言分类学

编译、虚拟机、脚本

• 编译型语言具有最好的效率，也是历史最悠久的语言类型。C 语言就是这类语言的代表。编译型语言在环境兼容和内存管理方面，往往不尽如人意，但是还是有很多后续的编译型语言在这方面做了长足的改进，譬如 Go 语言。作为环境兼容性“差”的另外一面，编译型语言生成的程序，在已经兼容的环境中，部署方面往往会比较简单，譬如用 Delphi（Object Pascal） 写的 GUI 程序，编译之后只有一个可执行 exe 文件，拷贝到目标机器上就能运行。
• 在“虚拟机”下运行的语言，往往都具有非常丰富的运行时动态特性，譬如 JAVA 和 C#，反射功能只是一个最基本的操作，它们还可以运行时更新代码，甚至可以支持很多不同的语言在同一个虚拟机上跑（如 Jython 就是用 Python 语言跑在 JAVA 虚拟机上）。比较有趣的是，几乎所有这类的语言，都号称要“跨操作系统”。事实上它们也基本上都做到了这点，但是真正用于编写 PC 或者服务器的跨操作系统的项目非常少，反而在手机、游戏领域，JAVA（安卓） 和 C#（Unity） 这些语言却应用非常广泛。最后说说性能，在 JIT（Just In Time）技术的加持下，很多虚拟机字节码，实际上拥有了和编译语言一样的基础性能，而那些无法 JIT 的代码，往往是编译型语言不支持的一些动态特性。所以除了部署安装这类语言编写的软件，需要额外按照个环境（JRE/.NET）以外，使用起来没有什么实质上的差异。
• 脚本语言的历史其实一点也不比其他语言更短，尽管它们被认为是最容易学习，但性能最差的一批。这类语言的一般都具有所谓的“动态类型”特性，也就是你可以不理睬变量的类型，直接把变量思维万能的信息盒子。甚至一些常用的数据结构，也被一种很容易使用的方式嵌入在语言中，譬如世界上最好的语言 PHP 就可以使用其万能的[ ]中括号——它既可以是数组，又可以是列表，还可以是哈希表。脚本征服“跨操作系统”难题，采用的另外一种方法：让自己的源码变得方便移植。其实这个方法，C 语言很早就尝试过，所谓的 ANSI C，就是明白无法让 C 语言编译出来的程序在任何环境运行，那就让 C 语言的源码变得可以在任何环境编译吧，虽然这个尝试现在来看不是太成功，因为我们使用 C 语言的一个重要理由，就是用来对操作系统进行控制，不同的操作系统提供的 API 本身就差异很大。脚本类语言只需要在不同的操作系统上，实现一遍自己的解析器，就可以成为所谓的跨操作系统了。其中一些语言（譬如 Python），还会连带把自己的常用库也移植到不同的操作系统上，而另外一些语言，压根就没有什么库，它的设计目的就是“寄生”（嵌入）到其他语言编写的程序中（如 Lua），所有需要移植的“库”，都是被嵌入的那种语言自己需要解决的问题。

1. 人是第一要素：也就是这个项目的开发人员，最适合用哪种语言。一般来说脚本语言的开发速度是最快的，如果是复杂多变的需求，首选脚本语言。
2. 运行环境的依赖因素：如果要开发一个“跨语言”可用的库，C 语言几乎是唯一的选择；如果要开发一款游戏，希望运行在不同的平台上，使用带虚拟机的语言，或者是某种脚本语言，譬如 TypeScript 可能是一个好的选择，很多游戏引擎、框架本身也会选择这一类语言。如果开发的程序可预见的，和某些环境依赖非常密切，那么就不要自找麻烦，直接选择环境相关的“官方语言”。
3. 性能几乎是最后的一个考虑要素，除非有非常明确的性能测试结果，不要轻易用这个标准来选择语言。

通用型和专用型

select name, age, address from User where name = 'Tom';

编程语言的理解思路：用什么手段，解决了什么问题

提高开发效率

跨平台

安全性

和游戏有什么关系呢？

为什么是 C++ ？

为什么不是 C++ ？

Talk is cheap, show me the code