程序员是否应该掌握 C++
我想知道程序员是否有必要拥有至少一种编程语言的专业知识？
C#、java、VB.Net 等编程语言每一两年都会发生变化。程序员是否应该掌握 C++ 这种稳定且很少发生变化的语言？
我是一名 C# 开发人员，使用它已经大约 7 年了，但我仍然没有掌握它。
编辑 我认为我的问题被误解了。我并不反对改变或进化。我喜欢 C#、VB、Java 等语言提供的新功能和抽象。我一直在等待新功能是否能让程序员的生活变得轻松。但这一事实也使得这种语言非常难以掌握。它们在不断发展。像 C++ 这样的语言的演化周期很慢。那么考虑到这种情况，掌握 C++ 有帮助吗？这就是我原来的问题的意思。 注：- 根据下面朋友的回答，我了解到语言和框架是表达概念的工具。用不同的编程语言表达概念也可能是个好主意。
I was wondering if it is necessary for programmers to have expertise on at least 1 programming language?
Programming languages like C#, java, VB.Net etc change every year or two. Should a programmer have mastery over C++, which is a stable language and rarely undergoes changes?
I am a C# developer and using it for about 7 years now, I still don't have mastery on it.
EDIT
I think my question is being misunderstood. I am not against changes or evolution. I love the new features and abstraction provided by languages such as C#, VB, Java. And I keep waiting for new features if it makes a programmers life easy. But this fact also make this languages very difficult to master. They are continuously evolving. Languages like C++ have slow evolution cycle. So given this scenario, Is it helpful to be master of C++? This is what my original question meant.
Note:- Based on the answers by friends below, I have understood that languages and framework are tools for expressing the concepts. Also it might be a good idea to express the concepts in different programming languages.
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（22）
它们不会“改变”，而是会进化。您的知识和经验不会丢失。
编程就是新的和变化的。如果你不喜欢这个职业，可以考虑换一个职业。
如果你要达到精通，生活就会变得无聊，甚至毫无意义。也许重要的不是目标而是道路？
编辑：阅读您的评论后，我觉得您将 .NET 类库的数量错误地归因于 C# 语言本身的复杂性。不要混合它们。 C#语言比较简单，很容易“掌握”。您提到的 char 数据类型的有用方法只是 .NET 库中的辅助方法。它是该平台的资产之一。这就是 .NET 开发人员如此高效的原因，因为他们不必浪费时间挖掘第三方库来为他们进行基本操作：XML、图像、网络、数据库等等，所有这些都可以直接从 .NET 库中获得。当然，它的巨大规模可能会吓到你，并给人一种无穷无尽的印象。不是这样的！只需使用您需要的，剩下的就不用管了。
They don't "change" but evolve. Your knowledge and experience are not lost.
Programming is all about new and change. If you don't like it, consider another profession.
If you were to achieve mastery, the life would become boring and maybe even pointless. Maybe it's not the target but the road that matters?
EDIT: After reading your comments I feel that you misattribute the volume of the .NET class library to the complexity of the C# language itself. Don't mix them. The C# language is relatively simple, it's easy to "master". What you're mentioning as useful methods of the
chardatatype are just helper methods from the .NET library. It's one of the assets of the platform. It's what makes .NET developers so productive, because they don't have to waste hours digging for third-party libraries to make basic operations for them: XML, imaging, networking, databases and more it's all available directly from the .NET library. Naturally, its sheer size might frighten you and provide an impression of it's being endless. It ain't! Just use what you need and leave the rest be.在我使用 C++ 的过程中，C++ 已经发生了巨大的变化，并且随着 C++0x 标准的采用，它即将经历另一次巨大的变化。如果你不喜欢改变，那么你就做错了事。
至于“掌握”，我想说，任何声称完全掌握 C++ 各个方面的人都可能是在说谎（其中包括像 Stroustrup 这样的人，如果他曾经说过这样的话）。大多数经验丰富的 C++ 程序员都是该语言的一个子集方面的专家，这对于解决他们感兴趣的特定问题非常有用 - 如果他们不了解该子集，那么他们的知识匮乏很快就会显现出来。但当然，他们同样可以快速学习新东西。
C++ has changed enormously in the time I've been using using it, and is just about to undergo another enormous change with the adoption of the C++0x standard. If you don't like change, you are in the wrong business.
As for "mastery", I would say that anyone who claims complete mastery of every facet of C++ is probably lying through their teeth (and that would include people like Stroustrup, if he ever said such a thing). Most experienced C++ programmers are expert in a subset of the language which is useful for addressing the specific problems they are interested in - get them outside the subset and their lack of knowledge becomes quickly apparent. But of course, they can equally quickly learn the new stuff.
不止一个！ ACM 杰出科学家 Kathleen Fisher 撰写了 “我们需要不止一种” 这解释了为什么理解多种编程语言如此重要。这篇文章涉及面很广，但特别提到了 C++。
不一定。两点：
C++ 看起来稳定只是因为它生命周期较晚，并且在其他语言变得越来越流行时保持相对稳定< /强>。如果您在 20 世纪 90 年代工作，您会认为 C++ 非常不稳定。请参阅 Jim Waldo 的优秀著作 C++ 的演变。即使是现在，当 C++0x 标准最终被采用时，C++ 也即将经历另一场动荡。
对于任何程序员来说，深入理解某种具有显式内存管理并且使用位、字节和字在机器级别进行编程的语言都是非常有价值的。 C 语言在这方面稍好一些，但 C++ 是一种非常好的机器级编程语言。然而，至少在我看来，重要的是理解如何使用字节、单词和指针进行编程，而不是模板或受保护成员字段之类的黑暗角落。
深入了解如何使用泛型进行编程对于任何程序员来说都是非常有价值的。 C++ 模板几乎不适合，因为（尚）不可能独立地对 C++ 模板进行类型检查。更好的模型包括 Java 泛型、C# 泛型以及 Haskell 和 ML 中的参数多态性
几乎不可能掌握像 C++ 这样复杂的东西，或者就 Haskell 或 Perl 或 Common Lisp 而言。如果你想完全掌握某些东西，你必须坚持使用一种非常简单的语言，比如 Lua。
More than one! ACM Distinguished Scientist Kathleen Fisher has written "We Need More Than One" which explains why it is so important to understand multiple programming languages. The essay is wide-ranging but it mentions C++ specifically.
Not necessarily. Two points:
C++ appears stable only because it is late in its life cycle and is remaining relatively steady while other languages grow more popular. Had you been working in the 1990s you would have viewed C++ as very unstable. See Jim Waldo's excellent book The Evolution of C++. Even now, C++ is about to undergo another convulsion when the C++0x standard is finally adopted.
It is very valuable to any programmer to have a deep understanding of some language that has explicit memory management and in which you program at the machine level, using bits, bytes, and words. The C language is a bit better for this purpose, but C++ is a perfectly good machine-level programming language. However, in my opinion at least, what's important is understanding how to program with bytes, words, and pointers, not the dark corners like templates or protected member fields.
It is very valuable to any programmer to have a deep understanding of how to program with generics. C++ templates are barely suitable, because it's not (yet) possible to type-check a C++ template independently. Better models include Java generics, C# generics, and parametric polymorphism as found in Haskell and ML
It is nearly impossible to master anything as complex as C++—or for that matter Haskell or Perl or Common Lisp. If you want complete mastery over something you have to stick to a very simple language like Lua.
我相信真正的“大师”程序员拥有多种工具集。她可能专注于一种或多种语言，但总的来说，她将确保涵盖更广泛的基础，而不是更深入地研究微小的细节。
我发现一些有用的东西：
拥有这些知识将使您成为任何语言的更好的程序员。
I believe a true "master" programmer has a varied toolset. She may be specialized in one or more languages, but overall she will make sure that a broader set of bases is covered, rather than going deeper into tiny specifics.
Some things that I find useful:
Having those under your belt will make you a better programmer in any language.
我用六种语言进行编程，但是对“裸机”概念的透彻理解可能是帮助您在不同语言之间进行切换的最佳拐杖。
对我来说，这意味着了解 c/c++。例如，一旦您可以欣赏 Linux 内核的面向对象设计（用 C 编写），就很容易欣赏其他语言提供的“捷径”（读取核心语言功能）以及何时以及如何评估其效率。
所以，是的，我认为对低级语言的良好理解对于任何程序员来说都是一笔宝贵的财富。 C/C++ 非常适合这个要求。
I program in half a dozen languages, but a thorough understanding of 'bare metal' concepts is probably your best crutch to help you between languages.
For me, this means knowing c/c++. Once, for example, you can appreciate the object oriented design of the Linux kernel - written in C - it's easy to appreciate the 'short cuts' (read core language feature) provided by other languages and when and how to asses there efficiency.
So, yeah, I think a good comprehension of a low level language is great asset to any programmer. C/C++ fits this bill perfectly.
如果您使用 C++ 那么您应该了解该语言的特性。我曾经是一个非常高级的 C++，但现在我使用 C#，那么我就必须刷新它。有时拥有太多的知识可能会造成干扰，所以我不在乎。
答案：每天编写 C++ = 是，编写 c# = 否
请明确，除非您每天都在做这件事，否则您无法掌握类似的事情，至少对我来说是这样。
If you use C++ then you should know the language features. I used to be a very high level C++ but now I use C# then I'd have to refresh on it. Sometimes having too much knowledge can be interference so I don't care.
Answer: Code C++ everyday = yes, code c# = no
Be clear you can't have mastery over something like that unless that is all you are doing or at least every single day, at least it was that way for me.
大多数编程语言都在不断变化和发展，C++ 也是如此。标准的每一次新修订都会带来语法变化，其中主要修订版 (C++0x ) 即将到来。尽管相对于技术进步而言，该标准的新版本可能相当罕见，但对该技术的理解仍在不断发展。例如，当当前的 C++ 标准首次出现时，大多数人都没有使用模板或异常。随着人们获得新功能的经验，他们不仅了解了机制本身的语法，还了解了使用这些设施的更大含义。如果您查看今天编写的应用程序，它可能看起来与几年前编写的应用程序有很大不同，即使两者都是由“专家”编写的。
如果你想成为一名程序员大师，那么通向大师的道路就是学习。尽你所能，在尽可能多的不同领域。我相信做到这一点的最佳方法之一是学习尽可能多的语言，即使只是为了获得对该语言的基本理解。学习所有“大”语言，如 C++、VB、Java、C# 等。但不要仅限于它们。还要学习小语言和更多的学术语言。您学习的每种语言不仅教您该语言，还教您如何编程。
看看这本书，7 周掌握 7 种语言
Most programming languages change and evolve continuously, and the same is true of C++. Syntactic changes come with every new revision to the Standard, and a major one (C++0x) is on the horizon. But even while new versions of the Standard might be fairly infrequent relative to the advancements in technology, the understanding of that technology continues to evolve. For example, when the current C++ Standard first came to be, most people were not using templates or exceptions. As people gained experience with the newer features they learned not only the syntax of the mechanism itself, but the larger implications of using those facilities. If you look at an application written today it may look much different than an application written just a few years ago, even if both were written by "experts."
If you want to become a master programmer, then the path to mastery is learning. As much as you can, in as many different areas as possible. I believe one of the best ways to do this is to learn as many languages as possible, if only to gain a rudimentary understanding of that language. Learn all the 'big' languages, like C++, VB, Java, C#, etc. But don't limit yourself to them. Learn the little languages too, and the more academic languages. Every language you learn teaches you not only that language, but how to program.
Take a look at this book, 7 Languages in 7 Weeks
一个好的程序员应该了解尽可能多的语言。 C++ 在那里没有特殊的地位。懂 C++ 的程序员比不懂 C++ 的程序员好，就像懂 Python 的程序员比不懂 Python 的程序员好一样。
如果您不需要编写 C++ 代码，那么不，您不需要特别成为 C++ 专家。这并没有坏处，学习这门语言肯定会教给你一些可以在其他语言中使用的东西。
但其他语言也是如此。
A good programmer should know as many languages as possible. C++ doesn't have a special status there. A programmer who knows C++ is better than one who doesn't, just like a programmer who knows Python is better than one who doesn't.
If you don't need to write C++ code, then no, you don't particularly need to be an expert at C++. It doesn't hurt, and learning the language will certainly teach you things that you can use in other languages as well.
But the same is true for other languages.
程序员应该具备概念方面的专业知识，这几乎就是全部:)
Programmer should have expertise on concept that's almost all :)
您是否“精通”英语（或您所说的任何语言）？我已经讲英语30多年了，但仍然没有掌握它。在这方面，我认为英语和 C#（C++、VB、Javascript...）之间没有太大区别。
语言不断发展，不断学习，这是你能做的最好的事情。
Do you have "mastery" over English (or whatever language you speak)? I have been speaking English for 30+ years and still don't have mastery over it. In this respect, I don't see much difference between English and C# (C++, VB, Javascript....)
languages evolve, keep learning, that is the best you can do.
我认为你正在混合语言和库。虽然您提到的语言确实发生了变化，但它们的变化通常会因其类库的变化而黯然失色（并且通常与之配对）。
话虽这么说，这些语言没有什么“不稳定”的地方。它们通过生长而不是移动来“改变”。 C++（作为一种语言）在很大程度上保持静态这一事实既不是好事也不是坏事。
I think you're mixing languages and libraries. While the languages that you mentioned do change, their changes are usually eclipsed by (and are often paired with) changes to their class libraries.
That being said, there's nothing "unstable" about these languages. They "change" by growing, not moving. The fact that C++ (as a language) stays largely static is neither a good nor a bad thing about it.
想要掌握某件事，实际上需要付出努力。
语言只是一种工具，而不是一种特权，就像文本编辑器和 xml 解析器一样。
程序员必须拥有强大的独立于语言的知识，可以应用于每种工具和语言来解决问题。
有人说编程是一门艺术，无论使用什么工具和技术，艺术仍然是艺术。
To master something actually requires to work hard with that something.
Languages are only a tool, not a prerogative, like text editors and xml parsers.
A programmer must have a strong language independent knowledge that can be applied at every tool and language to resolve problems.
Somebody says that programming is an art, and art is still art, regardless the tool and tecniques used.
我也曾就此问过自己类似的问题。我的观点（从一个什么都不是的 C# 程序员）是，你到达了一个阶段，语言成为达到目的的手段。只要您了解该语言的基础知识，您就可以使用任何语言进行操作（我曾经使用过 C++、VB 和 Python）。
它是一门语言的高级领域，允许您进一步控制，您会认为将“专业 X”程序员与“业余爱好者/偶尔 X”程序员区分开来（我了解 C++，但我偶尔使用它。我了解 C#并每天使用它。）。
不要担心不懂某种语言 - 归根结底，语言将继续发展 - 它们都不能保证在您的职业生涯中一直存在（尽管有些语言很可能会存在，哈哈）。
I've questioned myself similarly on this. My opinion (from being a nothing-to-C# programmer) is that you reach a stage where the language becomes the means to an end. You can do stuff in any language so long as you know the basics in it (I've had to do bits in C++, VB, and Python).
Its the advanced areas of a language that allow you further control and what you would argue separates the "Professional X" programmer from the "Hobbyist/Occasional X" progammer (I know C++, but I use it once in a while. I know C# and use it every day.).
Don't worry about not knowing a certain language - at the end of the day, languages will continue to evolve - none of them are guaranteed to be in existence for the duration of your professional career (though some are highly likely to lol).
我认为答案是，这取决于您需要做什么，以及您是否想要专业化或拥有更一般的经验/技能（不要低估后者，即使它并不总是那么流行）。这与大多数工程（实际上是其他）学科类似，我认为没有正确或错误的方法。
用汽车行业作为一个简单的类比，在一个乡村小镇开设一家沃尔沃专家不太可能是一个明智的商业举措，在那里，更广泛的汽车维修业务可能是一个更合适的企业（当然，除非你住在瑞典。 ..)。在一个富裕的大城市地区，情况很可能相反。每个企业都需要不同水平的专业和“通才”技术技能（和工具）。
话虽如此，如果您确实有机会深入了解一种语言和/或环境，您可能会发现您的经验对您在其他语言/环境中也有帮助。
I think the answer is that it depends on what you need to do and whether you want to specialize or have more general experience/skills (don't discount the latter even if it is not always as fashionable). This is similar to most engineering (and indeed other) disciplines, and I don't think there is a right or wrong approach.
Using the auto industry as an easy analogy, opening a Volvo specialist in a small rural town is unlikely to be a smart business move, where a more general auto repair business would probably be a more appropriate venture (unless you live in Sweden of course...). In a large affluent urban area, the opposite may well be the case. Each business would require different levels of specialist and 'generalist' technical skills (and tools).
Having said that if you do have the opportunity to get a deep knowledge of one language and/or environment, you will probably find that your experience with it will help you in other languages/environments also.
我想说，程序员有必要拥有至少一种编程语言的专业知识，最好是两种。
这里的关键词是“专业”，而不是精通；我同意几位发帖者的观点，即真正掌握大多数通用编程语言是一种难以捉摸且模糊的卓越水平，可能超出了大多数软件专业人员的成就。问题不在于缺乏时间或能力，而在于缺乏对广泛的编程问题的全面接触。您最终会受到组织内当前可以从事的项目类型等的限制。
对一种语言专业知识的需求是显而易见的。至少两种语言的良好水平的知识和经验有助于更好地理解任何给定语言的局限性，并为为给定项目选择合适的工具提供可行的选择。掌握两种以上语言的专业知识也可能是可取的，但我发现在实践中无论深入程度都很难。一般来说，一个人在多种编程语言中保持高度专业知识的能力在前 2-3 种语言之后会迅速下降。
最终，重要的是建立和维护对当前正在做和/或期望在不久的将来执行的工作类型最有用的任何语言的专业知识。跟上变化，尝试新工具，并准备好在需要时采用和接受一些全新的东西。
I would say it's necessary for programmers to have expertise in at least one programming language and preferably two.
The keyword here is "expertise", not mastery; I agree with the opinions of several posters that true mastery of most general-purpose programming languages is an elusive and nebulous level of excellence probably beyond the achievement of most software professionals. The issue is not so much lack of time or ability but rather a lack of comprehensive exposure to a very broad range of programming problems. You are ultimately limited by the type of projects that you can currently work on within your organization(s), etc.
The need for expertise in one language is obvious. A decent level of knowledge and experience in at least two languages is useful to better understand the limitations of any given language, as well as to provide viable options for choosing an appropriate tool for a given project. Expertise in more than two languages may also be desirable, but I find it to be difficult in practice to any degree of depth. Generally one's ability to maintain a high degree of expertise in multiple programming languages declines rapidly after the first 2-3.
Ultimately, the important thing is to establish and maintain expertise in whatever languages are most useful for the type of work that one is currently doing and/or expects to perform in the near future. Stay abreast of changes, try new tools out, and be prepared to adopt and embrace something fundamentally new whenever the need arises.
我认为C++是一个错误。与 C 的兼容性从一开始就扼杀了该语言，多年来缺乏良好的模板库给程序员带来了麻烦。
现在它相对稳定和成熟，它仍然是一个错误，很多基础设施试图杀死你，而一些基础设施确实帮助你。
我订阅这次“采访”中提出的大部分问题< /a>.
语言设计者试图首先解决语言的问题，Java 和 C# 的设计过于倾向于安全。
Go 是最近的一次尝试，旨在创建 C 语言，其类的设计速度、速度、速度。 Go 仍然不是主流，但如果取决于我的话，它就会成为主流。
总而言之，我认为 ANSI C 仍然是一种强大且有用的语言，是性能第一时的第一工具（或者考虑到 Go，第二工具）。
啊，而且你绝对可以在几个月内掌握 C，语言设计并不是为了对解决方案的结构提出问题。
我肯定会向学生教授 C 语言，也许还会教 Python 或 Java（或 Go）来展示 OO 实践和设计。
I think that C++ is a mistake. Compatibility with C has killed the language from the start, lack of a good template library has put in trouble programmers for years.
Now that it is relatively stable and mature, it remain a mistake, with a lot of infrastructure trying to kill you and some infrastructure really helping you.
I subscribe to most of the questions raised in this "interview".
Language designers have tried to fix the problems of the language first with the design of Java and C# leaning too much on the safe side.
Go is a more recent attempt to create a C with classes with speed, speed, speed in its very design. Go is still not mainstream, but it would, if it depended on me.
All in all, i think that ANSI C is still a powerful and useful language, the number one tool when performance comes first (or number two, considering Go).
Ah, and you can definitely master C in a few months, the language design is not made to raise questions on the structure of the solution.
I would definitely teach C to students and maybe Python or Java (or Go) to show OO practices and design.
我的问题在于“掌握”这个词。
我怀疑如果你一生都在学习，你是否能理解任何一门学科的每一个细微差别。
我已经讲英语 33 年了，但有时仍然对它的形式感到困惑。
My problem is with the word "mastery".
I doubt if you studied your entire life, that you'd understand every nuance of any one subject.
I've been speaking English for 33 years and still find myself at a loss as to the form it takes sometimes.
Java、C# 的“问题”在于，您不仅需要学习该语言，还需要学习它附带的库。现在拿C++来说，如果我告诉你你还需要用它学习ATL和MFC并记住所有这些东西......这是不可能的
The 'problem' with Java, c# is that you don't just have to learn the language but also the libraries that come with it. Now take C++ what if I told you you also need to learn ATL and MFC with it and memorize all those things...this would be impossible
在我们的宇宙中，一切都在不断变化。
In our universe, everything is constantly changing.
真正重要的是不要花几分钟在谷歌上搜索编写东西的最佳方式的答案，而是编写好的代码的能力或搜索它的能力和愿望，C#、java、VB.Net 的目的是抽象使您的模型干净、安全且不易出错，并尽可能以人类可读的方式编写代码。如果您想开发游戏、Windows 程序、Linux 程序、驱动程序或任何真正需要最佳性能的程序，或者可能赢得最模糊代码行的竞赛，请选择 C++，另一方面，您应该选择另一个平台。我喜欢不断发展的技术，这是优点而不是缺点。
What is really important is not loose some minutes googling an answer for the best way to write something, is the ability to write good code or the ability and the desire to search for it, C#, java, VB.Net are are intended to be abstractions that made your model clean, safety and less error prone, and writing code as human readable as possible. If you want to develop games, program for windows, linux, drivers, or everything that needs really the best performance or maybe win a contest for most obscured line of code, choose C++, in the other hand you should choose a another platform. I love technologies which evolve, that's a merit not a defect.
我认为没有必要自学一门你认为自己不会使用的语言。不过，掌握一些 C/C++ 知识是件好事，如果您有兴趣并且有时间学习 C++，那么请务必继续。学习新东西总是没有坏处的。我拥护多面手、在特定领域具有专长的开发人员。
掌握一门语言是很难达到的……这意味着要从心里了解图书馆的大部分内容。使用库中的许多不同的包/命名空间编写代码需要花费大量时间。作为一个从事 C/C++ 和 Java/C# 工作大约四年的人，我想说我对这个库有必要了解。我不断遇到需要学习/使用的库的新部分。对我来说，.NET 编程的挑战是学习如何使用框架的新部分。编写代码包含我多年来一直使用的相同的可转移编程技能。
让我问你一个问题：
你自然地用什么语言“思考”？我知道，当我第一次处理一个问题时，我似乎很自然地用 C 来思考简单/低级的东西，而当我处理一个适合面向对象的项目时，我似乎自然地用 C++ 来思考。
I don't think it's necessary to teach yourself a language you don't think you're going to use. Some C/C++ knowledge is good to have in your repertoire though, and if you have some interest and some time in learning C++ then by all means go right ahead. It never hurts to learn something new. I'm an advocate of developers who are generalists, with specializations in specific areas.
Mastery of a language is something that is difficult to attain... it would suggest knowing a large chunk of the library from heart. That takes a lot of time writing code with a lot of different packages/namespaces from the library. As someone that's done some C/C++ and Java/C# for about four years, I'd say that I'm on a need-to-know basis for the library. I'm constantly encountering new parts of the library that I need to learn/use. The challenge in .NET programming, for me, is learning how to use new parts of the framework. Writing the code consists of the same transferrable programming skills I've been using for years.
Let me ask you a question:
What language do you naturally "think" in? I know that when I approach a problem for the first time, I seem to naturally think in C for simple/low level stuff, and C++ when I'm dealing with a project that lends itself to object-orientation.
使 C++ 稳定的因素也使其难以掌握：它庞大、复杂且相对完整。
The same factor that makes C++ stable makes it hard to master: it's large, complex, and relatively complete.