#define 若 if
#define 否则 else
#define 为 for
#define 当 while
#define 做 do
#define 整型 int
#define 字符 char
#define 短整 short
#define 单精数 float
#define 双精数 double
#define 结构体 struct 多页面视图
那么,C语言现在已经支持中文关键字了。
中文编程语言已经有了。
类似的,你也可以如此对待C++。
其他编程语言或许没有宏,做不到如此轻易,但写个程序做个字符串替换,这是初中生都能办到的。
哪怕现在最最复杂的语言也不过几十个关键字而已——前面我说过了,关键字就对应于数学符号,和+-×÷=、Σ、lim、|x|、∫等等都是一回事(数学符号往往还比编程语言关键字多得多,比如c语言据说就是32个关键字、48个运算符:运算符就是数学符号)。
总之,或者你利用宏,或者直接写个转换程序——这个程序完全可以是通用的,定义个转换表就能对付所有语言,就好像uedit/notepad++的语法提示那样,简单的识别-替换就足够用了——任何编程语言都能当即变成“中文编程语言”。
这事的难度就有这么低。
按照IT界一贯的尿性,如果这种东西真那么好用、那么有用的话,那么你到github上随便一搜,一定能得到一大堆的“中文编程头文件”“中文程序转换器”。
你看,只要你把C语言的32个关键字翻译一下,写到头文件里,github一丢,轻轻松松拿到几十几百万个star。
30分钟拿百万github star,这事真是想想都能笑醒。
但为什么就没人做这事呢?
太简单了。
俩字:扯淡。
就好像做数学题你不写Σ写求和、不写lim写极限、不写ln写以e为底的对数一样,纯属扯淡。
你不仅是为自己找别扭,你也是为所有看你的证明的人找别扭。
这一套符号,本就是键盘输入最简单、区分度最高又最为约定俗成的一套“速记符”;替换它不仅毫无意义,反而带来了输入、阅读、记忆诸方面的许多负担。
尤其是,诸如指针的指针、类A里面的类B对象的方法C返回的数据结构D里面的元素E这样的东西,拿“速记符”写,轻巧短小,一目了然;拿其他任何东西写……
只要真的接受过几天正规的编程教育,你就知道这东西纯属扯淡。
就好像只要上了初中,你就一定会写 4x+3y=20、就绝不会支持“四乘天元加三乘地元等于二十”这种写法一样。
因此,不会有人把这种东西丢上github,丢上去也不会有人关注它——除非故意恶搞。
反过来说也对:那些最为大力支持中文编程的人,也不会写这么个头文件出来。
因为这种东西,尽管吹、别落地,它看起来就是高大上的——越玄乎越好。
一旦落地,其中的荒谬滑稽,就透了出来。
嘴炮结束。现在让我们回归传统吧——talk is cheap, show me the code!
这是一段实际项目中的源代码。当然,我“鸡贼”的改了函数名,免得某些滥竽充数的家伙直接搜一些结论蒙混过关。
当然,这是段非常简单的代码。只要你的数据结构能学会六成以上,这是什么算法,你大概已经心中有数了。
嘘~~
别出声!
和我一起调戏调戏那些“中文编程党”吧【坏笑】:
void __cdecl SplitSort (
void *base,
size_t num,
size_t width,
int (__cdecl *comp)(const void *, const void *)
)
{
char *lo, *hi; /* ends of sub-array currently sorting */
char *mid; /* points to middle of subarray */
char *loguy, *higuy; /* traveling pointers for partition step */
size_t size; /* size of the sub-array */
char *lostk[STKSIZ], *histk[STKSIZ];
int stkptr; /* stack for saving sub-array to be processed */
if (num < 2 || width == 0)
return; /* nothing to do */
recurse:
size = (hi - lo) / width + 1; /* number of el's to sort */
if (size <= CUTOFF) {
shortsort(lo, hi, width, comp);
} else {
mid = lo + (size / 2) * width; /* find middle element */
/* Sort the first, middle, last elements into order */
if (comp(lo, mid) > 0) {
swap(lo, mid, width);
}
if (comp(lo, hi) > 0) {
swap(lo, hi, width);
}
if (comp(mid, hi) > 0) {
swap(mid, hi, width);
}
loguy = lo; /* traveling pointers for partition step */
higuy = hi; /* traveling pointers for partition step */
/* Note that higuy decreases and loguy increases on every iteration,
so loop must terminate. */
for (;;) {
if (mid > loguy) {
do {
loguy += width;
} while (loguy < mid && comp(loguy, mid) <= 0);
}
if (mid <= loguy) {
do {
loguy += width;
} while (loguy <= hi && comp(loguy, mid) <= 0);
}
do {
higuy -= width;
} while (higuy > mid && comp(higuy, mid) > 0);
if (higuy < loguy)
break;
swap(loguy, higuy, width);
/* If the partition element was moved, follow it. Only need
to check for mid == higuy, since before the swap,
A[loguy] > A[mid] implies loguy != mid. */
if (mid == higuy)
mid = loguy;
/* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top
of loop is re-established */
}
/* A <= A[mid] for lo <= i < loguy,
A > A[mid] for higuy < i < hi,
A[hi] >= A[mid]
higuy < loguy
implying:
higuy == loguy-1
or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */
/* Find adjacent elements equal to the partition element. The
doubled loop is to avoid calling comp(mid,mid), since some
existing comparison funcs don't work when passed the same value
for both pointers. */
higuy += width;
if (mid < higuy) {
do {
higuy -= width;
} while (higuy > mid && comp(higuy, mid) == 0);
}
if (mid >= higuy) {
do {
higuy -= width;
} while (higuy > lo && comp(higuy, mid) == 0);
}
/* OK, now we have the following:
higuy < loguy
lo <= higuy <= hi
A <= A[mid] for lo <= i <= higuy
A == A[mid] for higuy < i < loguy
A > A[mid] for loguy <= i < hi
A[hi] >= A[mid] */
/* We've finished the partition, now we want to sort the subarrays
[lo, higuy] and [loguy, hi].
We do the smaller one first to minimize stack usage.
We only sort arrays of length 2 or more.*/
if ( higuy - lo >= hi - loguy ) {
if (lo < higuy) {
lostk[stkptr] = lo;
histk[stkptr] = higuy;
++stkptr;
} /* save big recursion for later */
if (loguy < hi) {
lo = loguy;
goto recurse; /* do small recursion */
}
}
else {
if (loguy < hi) {
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr; /* save big recursion for later */
}
if (lo < higuy) {
hi = higuy;
goto recurse; /* do small recursion */
}
}
}
/* We have sorted the array, except for any pending sorts on the stack.
Check if there are any, and do them. */
--stkptr;
if (stkptr >= 0) {
lo = lostk[stkptr];
hi = histk[stkptr];
goto recurse; /* pop subarray from stack */
}
else
return; /* all subarrays done */
} 多页面视图
现在,我们汉化它的关键字,看看能不能降低理解难度:
空 函数调用模式乙 SplitSort (
空 *base,
尺寸类型 num,
尺寸类型 width,
整型 (函数调用模式乙 *comp)(不变的 空 *, 不变的 空 *)
)
{
字符 *lo, *hi; /* ends of sub-array currently sorting */
字符 *mid; /* points to middle of subarray */
字符 *loguy, *higuy; /* traveling pointers for partition step */
尺寸类型 size; /* size of the sub-array */
字符 *lostk[STKSIZ], *histk[STKSIZ];
整型 stkptr; /* stack for saving sub-array to be processed */
若 (num < 2 || width == 0)
返回; /* nothing to do */
/* If the partition element was moved, follow it. Only need
to check for mid == higuy, since before the swap,
A[loguy] > A[mid] implies loguy != mid. */
若 (mid == higuy)
mid = loguy;
/* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top
of loop is re-established */
}
/* A <= A[mid] for lo <= i < loguy,
A > A[mid] for higuy < i < hi,
A[hi] >= A[mid]
higuy < loguy
implying:
higuy == loguy-1
or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */
/* Find adjacent elements equal to the partition element. The
doubled loop is to avoid calling comp(mid,mid), since some
existing comparison funcs don't work when passed the same value
for both pointers. */
higuy += width;
若 (mid < higuy) {
做 {
higuy -= width;
} 当 (higuy > mid && comp(higuy, mid) == 0);
}
/* OK, now we have the following:
higuy < loguy
lo <= higuy <= hi
A <= A[mid] for lo <= i <= higuy
A == A[mid] for higuy < i < loguy
A > A[mid] for loguy <= i < hi
A[hi] >= A[mid] */
/* We've finished the partition, now we want to sort the subarrays
[lo, higuy] and [loguy, hi].
We do the smaller one first to minimize stack usage.
We only sort arrays of length 2 or more.*/
若 ( higuy - lo >= hi - loguy ) {
若 (lo < higuy) {
lostk[stkptr] = lo;
histk[stkptr] = higuy;
++stkptr;
} /* save big recursion for later */
若 (loguy < hi) {
lo = loguy;
去到 recurse; /* do small recursion */
}
} 否则 {
若 (loguy < hi) {
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr; /* save big recursion for later */
}
若 (lo < higuy) {
hi = higuy;
去到 recurse; /* do small recursion */
}
}
}
/* We have sorted the array, except for any pending sorts on the stack.
Check if there are any, and do them. */