整个 Linux 都是 C语言写的，创立者大牛 linus 很不喜欢C++之类 object-based语言。我也类似。 我感觉 object-based 之类的 写写 GUI还是可以的，可以直接调用那些GUI class 之类。但是写 算法之类的，还是麻烦。不出错还可以，一旦出错起来，很难调试Debug，特别是那些 继承了 二，三层的。现在有人写程序，为了 object而去人为的object，有很多问题其实是不需要 object的，反倒自找麻烦。当然你们可以认为我老套了。
jack54321 发表于 2021-12-10 11:52
多谢大牛。我有个问题想请教。 a is a global matrix varible. void f (int p; int i； int j) { 对a[i,j]进行赋值 } int core_algo (int [] x, int [] y) { 数组x和y是输入的数组。 在算法过程中，会产生一个巨大的数组a， 且还会不断调用函数f，对这个数组a进行更新赋值。 最后，依据x, y, 和a, 得出结果。并且输出 }
多谢大牛。我有个问题想请教。 a is a global matrix varible. void f (int p; int i； int j) { 对a[i,j]进行赋值 } int core_algo (int [] x, int [] y) { 数组x和y是输入的数组。 在算法过程中，会产生一个巨大的数组a， 且还会不断调用函数f，对这个数组a进行更新赋值。 最后，依据x, y, 和a, 得出结果。并且输出 }
大牛们。其实我最想问的是一个问题。 如何能把一个c#编写的面向对象程序，改写成C语言来实现。 特别关注的是 c#里面的一个类，它的成员变量可以被他的成员方法改变。这个如何C来实现呢？ class a { public x; public y; void f() { this.x = 10; } int g() { int z; z = this.x + this.y; } } 这个g函数，能不需要传递x和y作为形参，而得到他们的值。在c里面怎么能实现呢？
大牛们。其实我最想问的是一个问题。 如何能把一个c#编写的面向对象程序，改写成C语言来实现。 特别关注的是 c#里面的一个类，它的成员变量可以被他的成员方法改变。这个如何C来实现呢？ class a { public x; public y; void f() { this.x = 10; } int g() { int z; z = this.x + this.y; } } 这个g函数，能不需要传递x和y作为形参，而得到他们的值。在c里面怎么能实现呢？
大牛们。其实我最想问的是一个问题。 如何能把一个c#编写的面向对象程序，改写成C语言来实现。 特别关注的是 c#里面的一个类，它的成员变量可以被他的成员方法改变。这个如何C来实现呢？ class a { public x; public y; void f() { this.x = 10; } int g() { int z; z = this.x + this.y; } } 这个g函数，能不需要传递x和y作为形参，而得到他们的值。在c里面怎么能实现呢？
microsat 发表于 2021-12-10 12:24
用struct 来定义object, 用malloc来新建object, 用指针来执行各种method, 其实一个类，就是一个指针指向了一个struct，你了解原理就知道了。 ，我以前是汽车行业的，汽车行业都是C，但是有许多公司用C当作面向对象语言来用。其实你指针学好了，所有的东西在你看来都是指针。 比如C++ // Header classPoint { public: Point(int x, int y); ~Point(); intx() const; inty() const; private: constint x_; constint y_; }; // Source file Point::Point(int x, int y) : x_(x), y_(y) {} Point::~Point() {} intPoint::x() const { return x_; } intPoint::y() const { return y_; } 到了C语言就编程这样了 // Header structPoint; // forward declared for encapsulation Point* Point__create(int x, int y); // equivalent to "new Point(x, y)" voidPoint__destroy(Point* self); // equivalent to "delete point" intPoint__x(Point* self); // equivalent to "point->x()" intPoint__y(Point* self); // equivalent to "point->y()" // Source file structPoint { int x; int y; }; // Constructor (without allocation) voidPoint__init(Point* self, int x, int y) { self->x = x; self->y = y; } // Allocation + initialization (equivalent to "new Point(x, y)") Point* Point__create(int x, int y) { Point* result = (Point*) malloc(sizeof(Point)); Point__init(result, x, y); return result; } // Destructor (without deallocation) voidPoint__reset(Point* self) { } // Destructor + deallocation (equivalent to "delete point") voidPoint__destroy(Point* point) { if (point) { Point__reset(point); free(point); } } // Equivalent to "Point::x()" in C++ version intPoint__x(Point* self) { return self->x; } // Equivalent to "Point::y()" in C++ version intPoint__y(Point* point) { return self->y; }
用C语言里的 struct 来表示 C++ 里的属性atribute. private member function 用 C语言里的 static function 来写，仅限本文件使用。 public member function 就用 C语言里的 普通 function来写，或者加一个 extern 来表示。 差不多就这样了。那些 virtual function, 构造函数，解构函数我不知到怎么写，大概编译器里的事。 我以前公司还花钱买过一些C++的类库，我们还要吭哧吭哧把它改写成C语言的函数。
C++， C#这些面向对象的编译器，是不是都是basic或者C这样基于函数编程的语言来编译的？
说明：面向对象的程序，最终还是需要被翻译成函数编程或者流程编程的。 为何我们要多此一举，面向对象编程呢？而不是直接就函数或者流程编程呢？
有什么，是面向对象编程可以完成的，但是函数流程编程完成不了的？ 面向对象编程比函数流程编程简单吗？
readability, information hiding
很底层的操作系统、特别是涉及到性能问题的部分还是函数编程，因为要追求效率。
c basic是procedural programming lang，概念搞混笑了
不要过于纠结字面。
其实她就是问为什么要面向对象。
我觉得很多人写java写惯了的影响很深 哪怕些其他语言最后也还是java的样子
functional的精髓在哪？functions是first class？
精髓在于作弊，各种违规能让别人完全无法read～～
奇怪。C和Fortran怎么不是functioanl programming？
哈哈 true
我感觉 object-based 之类的 写写 GUI还是可以的，可以直接调用那些GUI class 之类。但是写 算法之类的，还是麻烦。不出错还可以，一旦出错起来，很难调试Debug，特别是那些 继承了 二，三层的。现在有人写程序，为了 object而去人为的object，有很多问题其实是不需要 object的，反倒自找麻烦。当然你们可以认为我老套了。
恩 有的时候确实只是为了谁都能看懂
看来你完全不懂什么叫functioanl programming。 C和Fortran是procedural programming。Scala, Haskell那样的才是functional programming。Functional programming难学，code难读。特别短是真的，因为code基本都是用各种奇技淫巧的recursion。
嗯 略懂皮毛的时候觉得functional写起来很爽
后来发现不懂精髓
而且写起来很爽的语言比较容易读起来很烦
那也得看是谁写的，一个训练有素的码工写出来的C代码还是可以读起来很爽的，但是一个习惯不好的就完蛋了。当然据说C代码到了10万行量级的，C代码就不行了，可扩展性急剧降低，所以才会使用C++。不过我倒是没编过那么大的程序，要是自己的不那么大的程序，我觉得C也挺好的，甚至比C++好
functional programming，用来写库是不错的。但我们公司和客户都不用FP，都是OO。
不过现在FP开始越来越流行了。C++11,到14 和17， 新增的feature,除了多线程，都是在把FP加入C++。 总的来说，FP在大学比在工业界流行，主要还是code的易读性和可维护性太低。
整个LInux远超过10万行了吧？不是好好的？比windows稳健多了。还是要整个架构规划好，各个模块尽量独立。
是的是的 属于学术性语言吧 可以motivate和inspire小孩子们
有很多有趣的东西 像python最早我记得就没有tail recursion （现在有木有我不知道） 初学scala就会觉得很爽
多谢大牛。我有个问题想请教。
a is a global matrix varible.
void f (int p; int i； int j) { 对a[i,j]进行赋值 }
int core_algo (int [] x, int [] y) {
数组x和y是输入的数组。 在算法过程中，会产生一个巨大的数组a， 且还会不断调用函数f，对这个数组a进行更新赋值。
最后，依据x, y, 和a, 得出结果。并且输出
}
如果不用class，怎么能编写这个呢？
昨晚刚给儿子讲到 constructor destructor.
python到现在也没有tail recursion。但是function在python算是first-class citizen。
定义搞错了。
基于函数来完成的procedural编程。
c语言的结构体struct类似class功能
训练有素的马工的标志， 写一句return 0后面都要加三行//～～
学习了
用指针啊？C语言里的 pointer啊。用指针 指着 数组a就可以了。 我现在感觉不用 指针 都不会编程序了，基本上每个程序都要用到指针。
因为你是大牛，但却回答不上来
特别关注的是 c#里面的一个类，它的成员变量可以被他的成员方法改变。这个如何C来实现呢？ class a { public x; public y; void f() { this.x = 10; } int g() { int z; z = this.x + this.y; } }
这个g函数，能不需要传递x和y作为形参，而得到他们的值。在c里面怎么能实现呢？
多谢！
C里面的指针，的确能搞定这个。
但是对于没有指针的语言，比如R。怎么能把C#语言的程序，改成R语言呢？ 还有matlab，怎么把C#改成matlab呢？
或者这么说。怎么在写一个C，R， Matlab程序的之前，就构思好了，日后，如何能方便的改写成面向对象的C++或者C#?
没啥特别好的办法啦，这里的x和y改个比较独特的名字，譬如ag_x和ag_y啥的，然后定义为static global变量，这样起码把它俩框在一个文件里了。
f <- function() { define f''s variables. g <- function() { 更新 f 的 变量 }
main <- function () { g() 读取f的变量，计算输出， }
main() 执行main函数 }
以上就是我用嵌套函数来实现的面向对象编程。 大家觉得如何？
这样编程的最大好处是，日后如果改成c#， 只需要把第一行改成
f = public class {
就可以了。
这个例子，也说明了，面向对象编程其实没什么新意。最终都是用函数来完成的。
如果是国内科班出来的，都是说面向对象编程。。。 我记得，20多年前，有个台湾同事要给他们台湾那边公司买参考书，然后去了大陆的书店都傻眼了，怎么都是面向对象编程啊。
典型的用struct来实现面向对象。不过C的struct没有member function，你只能用global或local的function。你要的code如下：
struct Microsat { int x; int y; };
int g(Microsat* foo) { return foo->x + foo->y; }
void main(void) { Microsat myStruct; myStruct.x = 10; myStruct.y = 20; int z = g(&myStruct); }
ＯＯ就是为了训练规范普通人用的， 天才都是，用两个手指打０１１０编程的～～
用struct 来定义object, 用malloc来新建object, 用指针来执行各种method,
其实一个类，就是一个指针指向了一个struct，你了解原理就知道了。
比如C++ // Header class Point { public: Point(int x, int y); ~Point(); int x() const; int y() const; private: const int x_; const int y_; };
// Source file Point::Point(int x, int y) : x_(x), y_(y) {} Point::~Point() {} int Point::x() const { return x_; } int Point::y() const { return y_; }
到了C语言就编程这样了 // Header struct Point; // forward declared for encapsulation Point* Point__create(int x, int y); // equivalent to "new Point(x, y)" void Point__destroy(Point* self); // equivalent to "delete point" int Point__x(Point* self); // equivalent to "point->x()" int Point__y(Point* self); // equivalent to "point->y()"
// Source file struct Point { int x; int y; };
// Constructor (without allocation) void Point__init(Point* self, int x, int y) { self->x = x; self->y = y; }
// Allocation + initialization (equivalent to "new Point(x, y)") Point* Point__create(int x, int y) { Point* result = (Point*) malloc(sizeof(Point)); Point__init(result, x, y); return result; }
// Destructor (without deallocation) void Point__reset(Point* self) { }
// Destructor + deallocation (equivalent to "delete point") void Point__destroy(Point* point) { if (point) { Point__reset(point); free(point); } }
// Equivalent to "Point::x()" in C++ version int Point__x(Point* self) { return self->x; }
// Equivalent to "Point::y()" in C++ version int Point__y(Point* point) { return self->y; }
这不是语言的锅，是写程序人的锅。不过现在也开始流行打破monolithic，做small service base的architect了。
我到现在也无法理性分出C和C++。我的认知就是差不多。尤其写function的时候，不用太fancy的东西，syntax大差不差
其实C++功能虽多，用不用还是在于写程序的人。其实struct也够用了。c++那些object oriented的东西，不谨慎用，确实很讨厌，尤其好多人一起在某个base上工作，会出现各种duplicate的问题。
一样感慨
用C语言里的 struct 来表示 C++ 里的属性atribute. private member function 用 C语言里的 static function 来写，仅限本文件使用。 public member function 就用 C语言里的 普通 function来写，或者加一个 extern 来表示。 差不多就这样了。那些 virtual function, 构造函数，解构函数我不知到怎么写，大概编译器里的事。
我以前公司还花钱买过一些C++的类库，我们还要吭哧吭哧把它改写成C语言的函数。
这个好 确实可以很大程度地让你想写成啥样就啥样
c struct member可以有函数指针，定义了函数之后初始化一下勉强也能算吧。当然local function还是得要的。= =
一个一个的函数，管理上就是大问题啊。
牛！
确实
hierarchical structure或tree like structure更符合人类大脑对世界的认知
虽然人人渴望世界扁平化 但大脑对知识的organize偏偏不是扁平化的
当年写编译器的时候，感觉对我们俗人来说，用C++方便了不少，结构更加合理严谨。C语言更加灵活，但是作为编程者，脑子必须够用，随着功能增加程序升级，复杂度上升的确实比较快，用C++就好多了。所以我写纯功能性代码1000行以内的，还是会首选C，结构更复杂的，行数更多的，那也会选用C++。
话说回来，其实很多人并没有学会OO的精髓，无非就是用C++搭了个架子，里面其实还是用的C。我当年就碰到过某州立大学的某编程小组，帮着他们改程序，结果发现他们也就是用visual C++先搭了个架子，然后里面还是老一套，甚至用了511个全程变量，他们给我的要求就是，尽量减少全程变量的个数。这个可把我累得够呛，基本上除了纯算法的一块，全都得重写一遍。。。
是的 很多时候大家都按自己的理念去写
所以写出很多像牛非马的东西
但也无妨啊 能跑能维护就行 大不了过几年重写呗
认知没用，大家都知道层级化更加准确，但是到了真正干活的时候，往往会因为对系统或者说工具的理解并不足够深刻而产生偏差，简单点说，就是老板的老板一着急，干脆跳过老板直接给你下达命令，不仅指导你做什么，甚至可以指导你怎么做，这多快捷有效啊，哈哈。
人这个东西就是这样，有时候明明知道某些东西好，但是一犯懒就将就了。我喜欢用latex做文档，但有的时候嫌麻烦就往往直接用word了，还是这玩意糙快猛。
像窥探一下大牛都在玩什么。显然不是我能玩的
511个全程变量这件事，和C语言还是C++没什么关系，纯粹是编程习惯不好。C语言里也基本上可以没有全程变量的。我现在除了很大的数组，不能放在堆栈里，要用全程变量外。其他的基本上已经不用全程变量了。
我还写过一万行的单个C 函数，确实比较难 维护点。但没办法，为了 节省函数调用开销。也为了自己的 job security.
哈哈，一万行。 是不是为了让别人看不懂，变量名都是 A1,a2,....A200
感觉是码婆的老公们在秀
是呀 通常就是这两派的斗争 快糙猛还是慢细精
搞来搞去的痕迹很明显 到处都是 感觉要follow convention都不容易 到底啥算convention
嗯 是的现在都不讨论了 像前面一位麻婆说的 反正都是micro services 管你背后用啥写的呢 你能解决问题能维护就好
C++ 一个产生的因素就是要减少指针的使用。甚至引用都不推荐。这种函数指针在强制类型转换和内存管理方面隐患太多了。
行业不同，自然语言不同。 像汽车，飞机，机器人，还有许多嵌入式领域，几乎统一都用C语言的。
所以就需要高质量编程的程序员呀。 芯片硬件等的条件会越来越好，但凡牵涉到安全，都是用C语言
embedded确实不一样
不使用引用难道传参都hard copy吗？
从来不知道有不推荐使用引用的。
以后还是少来huaren多学习比较好。与lz共勉。
天才都是直接脑子算得比Tesla P100快。
那是因为这些嵌入式系统用的人少，编译工具不先进，程序员水平也低的原因，并不是因为C有多么先进。
面向对象，当初翻译这个词的人肯定不懂编程。
没错，functional programming 是Lisp的那一套，和函数没有什么关系。
操作系统用C语言写，根本不是效率的问题，而是广泛应用的问题。因为CPP 的编译器比较复杂，不是每个系统都有高效的编译器。他写操作系统当然希望越广泛应用越好，所以只能选择C语言。好的C程序多少也实现了CPP的技术。
多谢！
Functional programming 的本质就是通过层层的递归把问题分解为小问题，直到不能分解为止，和函数指针没有本质的关系。 一般的编程就和写文章差不多，通过一步一步的指令来改变程序的状态。