don编程

㈠ C++语言是什么啊

一种编程语言~

C++，这个词在中国大陆的程序员圈子中通常被读做“C加加”，而西方的程序员通常读做“C plus plus”，它是一种使用非常广泛的计算机编程语言。C++是一种静态数据类型检查的，支持多重编程范式的通用程序设计语言。它支持过程序程序设计、数据抽象、面向对象程序设计、泛型程序设计等多种程序设计风格。

贝尔实验室的本贾尼·斯特劳斯特卢普（w:en:Bjarne Stroustrup）博士在20世纪80年代发明并实现了C++（最初这种语言被称作“C with Classes”）。一开始C++是作为c语言的增强版出现的，从给C语言增加类开始，不断的增加新特性。虚函数（virtual function）、运算符重载（operator overloading）、多重继承（multiple inheritance）、模板（template）、异常（exception）、RTTI、名字空间（name space）逐渐被加入标准。1998年国际标准组织（ISO）颁布了C++程序设计语言的国际标准ISO/IEC 14882-1998。遗憾的是，由于C++语言过于复杂，以及他经历了长年的演变，直到现在（2004年）只有少数几个编译器完全符合这个标准(这么说也是不完全正确的，事实上，至今为止没有任何一款编译器完全支持ISO C++)。

另外，就目前学习C++而言，可以认为他是一门独立的语言；他并不依赖C语言，我们可以完全不学C语言，而直接学习C++。根据《C++编程思想》（Thinking in C++）一书所评述的，C++与C的效率往往相差在正负5%之间。所以有人认为在大多数场合C++ 完全可以取代C语言(然而我们在单片机等需要谨慎利用空间、直接操作硬件的地方还是要使用C语言)。

㈡ 什么叫编程函数他有什么作用c++的结构是怎样的

我下面说的就是函数的定义，如果你不能完全理解的话我建议你先看看下面的C语言结构，不然别人再怎么给你解释你也听不明白：（

在某个变化过程中，有两个变量x、y，如果给定自变量x一个值，那么应变量有且只有一个变量与之对应，那么我们称y是x的函数。

人们对C++有许多不同的看法，保守的C++程序员坚持用其他语言创建COM组件，他们认为只有真正的程序员使用C++。另一方面，VB程序员认为C++是一种很难掌握和使用的语言，没有必要增加编程时间和进行艰难的尝试。java程序员认为他们比C++程序员强，因为James Gosling(Java的发明者)吸收了许多语言(包括C++ )的优点发明了Java，本章和下一章的目的就是消除对C++的偏见和错误概念。

本章集中介绍用C++ 建立服务器组件，不讲述C++语言，如果想学C++ ，请参阅Ivor.Horton着的《Beginning Visual C++6》，Wrox 出版，书号为ISBN 1-861000-88-X。

本章的主要内容有：

? C++简史。

? 使用C++原因。

? 从VB移植到C++。

? ATL、STL和MFC介绍。

? 建立一个COM组件。

? 错误处理与调试。

更重要的是应该记住，现在，不只是在用C++建立组件，可以使用Visual C++中可用的任何工具，使得建立过程更加容易。先从C++的起源谈起。

17.1 C++语言

在决定是否使用C++语言之前，最好是搞清楚这种语言的实质，让我们看一下C++的历史和现状。

17.1.1 C++简史

刚开始形成的是C语言，那些想建立更快更有效的代码的程序员非常欣赏C语言，有一位名叫Bjarne Stroustrup的人却不满足于仅仅是生产快速代码，他想创建面向对象的C语言编程。他开始对C语言的内核进行必要的修改，使其能满足面向对象模型的要求。C++从此产生。

Bjarne Stroustrup是C++的最初设计者和实现者。它自诞生以来，经过开发和扩充已成一种完全成熟的编程语言。现在C++已由ANSI、BSI、DIN、其他几个国家标准机构和ISO定为标准。ISO标准于1997年11月4日经投票正式通过。

C++标准演变了许多年。C++模板是近几年来对此语言的一种扩展，模板是根据类型参数来产生函数和类的机制，有时也称模板为“参数化的类型”。使用模板，可以设计一个对许多类型的数据进行操作的类，而不需要为每个类型的数据建立一个单独的类。标准模板库(Standard Tempalte Library，STL )和微软的活动模板库(Active Tempalte Library，ATL )都基于这个C++语言扩展。

C++标准可分为两部分， C++语言本身和C++标准库。C++标准库对于Visual C++是相当新的，实际上微软只是在发布Visual C++ 5.0时去除了一些“bug”。标准库提供了标准的输入/输出、字符串、容器(如矢量、列表和映射等)、非数值运算(如排序、搜索和合并等)和对数值计算的支持。应该说， C/C++包含了相对少的关键字，而且很多最有用的函数都来源于库，C++标准库实现容器和算法的部分就是STL。

STL是数据结构和算法的一个框架，数据结构包括矢量、列表和映射等，算法包括这些数据结构的查找、拷贝和排序等。1994年7月，ANSI/ISO C++标准委员会投票决定接受STL为C++标准库的一部分，这个建议是根据Alex Stepanov、Meng Lee和David Musser这三人的编程和软件库研究提出的。STL的产生是为了满足通用性的设计目标，而不是为了提高性能。

那么微软对C++标准的态度怎什么样？微软运行VC++与Plum-Hall C++，想比较得到的分数在92%和93%之间。为什么不是100%的一个原因是跟踪这个标准并同时建立一个编译器比较困难，微软也考虑了对现有编码兼容的重要性，有时他们不得不偏离标准以保持这个兼容性。

17.1.2 使用C++的原因

应该有充分的理由使用C++创建服务器组件，而不只是为了给上司一个好印象才使用C++。如果以前没用过C++，你必须要尽力学习。

1. 性能

性能有个两方面，算法速度和机器代码效率。一个算法可以定义为数据通过系统的概念化的路径，它描述一些点，在这些点上，数据能够被操作并可转换产生某个结果。例如，一个算法定义为获取一个字符串，计算字符串中的字符个数，并作为结果返回的过程。算法与

语言是独立的，所以在编程之前必须设计算法，编写一个快速程序的第一个步骤是设计良好的算法，能以最少的操作步骤得出问题的答案。第二个步是选择语言，这也影响程序的速度。

从性能的角度考虑，用汇编语言编写程序是最佳的选择，它是计算机能理解的自然语言。但是，几乎没有人用汇编语言编写完整的程序，因为这样做极其乏味。另一个最佳的选择是C语言。然而，由VC++提供的所有工具都产生C++，而不是C。使用VC++的向导可以生成大量的使用代码，而不必人工地编写代码。从编写程序的难易程度和程序的性能综合考虑， C++是最佳的选择。

C++性能良好，因为它被编译为机器代码。对于VBScript和Java等语言，代码在运行时由程序解释，而且每次运行程序时都要将代码转换为机器码，这样做效率比较低，不仅仅是已编译过的C++程序运行得较快，而且微软C++编译器已存在多年。这意味着微软的编译器程序员已经把许多优点集中到编译器上，以致于它能产生非常高效的机器码。因为C++是编译语言，而且非常自然，比VB更接近机器代码，所以由C++编译器产生的代码一定比VB的编译代码效率更高。

2. 错误处理

一个好的程序与一个伟大的程序的区别就是其是否具有良好的错误处理支持。实际上，如果在实现中首先进行错误处理，而不是在最后才进行，那么整个程序的开发和测试过程会更加完美。但是，错误处理只能与语言所支持的内容相一致。

VBScript具有基本的错误处理支持功能。在默认情况下，不能捕获VBScript中的错误。每次怀疑产生错误时，要调用On Error Resume Next功能，并检查Error对象。

而C++中的错误处理比较好，这是因为有“异常处理”，本章的后面部分将详细介绍。

3. 最小的依赖性

正如上面所说，C++是一种编译语言，即C++代码在执行之前已转换为机器码。只要此代码不依赖于外部的动态链接库(DLL)，C++就可以在不需要安装额外程序的情况下移动到运行同样操作系统的其他机器和微处理器上，而移动Java程序时需要先安装Java运行期库。

4. 利用现有的代码

由于C和C++已经存在许多年了，现在有许多可利用的代码，你的服务器组件可以使用现有的C/C++代码或库。例如统计库和到老系统的C接口。

5. 最大化COM特征

COM与C++很接近，实际上， Don Box(COM的权威)在他的《Essential COM》一书的第一章写道：“COM就是更好的C++”。他说明了COM规范是如何从C++语言规律中产生出来的。通过理解C++，会对COM有更深的理解。

某些语言不能利用所有的COM特征，而在C++中，几乎可以使用所有的COM特征。

17.1.3 不使用C++的原因

知道什么时候使用C++是重要的，同样，知道什么时候不使用C++也是重要的。想象一下那些长期维护代码的人，如果他们中没有一些C++程序员支持C++，那么开发者们不得不把眼光转向另外一些他们熟悉的语言。

改变C++组件时，为了看到这些改变的结果，必须重新编译该组件代码，这会花费很长的开发时间。C++不能像ASP页面代码那样，只使用记事本，改变代码的一行，重新装载而得到结果。因此，如果某些工作需要经常变化(如原型)，不要用C++。

在C++中，对一些致命的错误不能获得更多的保护，写一个使组件崩溃的代码是很容易的。这是为了提供快速代码而付出的代价， C++不会停下来去检查代码是否按设计运行能否使程序不崩溃依赖于开发者的技巧。如果在这方面花的时间较少或刚刚学习C++，最好不要使用C++。等到已经意识到C++中所有容易犯的错误，而且在检测组件之前花了许多时间，才可以使用C++，如果想很快、很容易地建立一个组件，而且也不考虑该组件的执行速度，那么使用VB吧！

17.1.4 把ASP技巧转到C++上

学习新东西的最好方法就是利用现有的技巧。对于ASP开发者来说，已经学习了C++所要求的许多技巧，特别是，JScript语法和ActiveX或COM的面向对象编程的概念。

1. JScript

大部分ASP开发者都用JScript在浏览器上使用DHTML。JScript的语法与C非常相似，所以，如果懂得JScript，那么就懂得基本的C语法。当然，只是C++语法的子集。C++有许多额外的语法来支持面向对象编程，这就是我们下一步要做的。

2. 面向对象编程

如果你在VB中使用过类(class)，则对任何COM对象和文档对象模型(Document ObjectModel，DOM )都应熟悉，因为已经有了面向对象编程(OOP)的概念。在前面已经说过， C和C++的区别是C++支持面向对象编程。

㈢ DRY编程原则 是什么

DRY 全称：Don't Repeat Yourself （摘自wikipedia），是指编程过程中不写重复代码，将能够公共的部分抽象出来，封装成工具类或者用“abstraction”类来抽象公有的东西，降低代码的耦合性，这样不仅提高代码的灵活性、健壮性以及可读性，也方便后期的维护或者修改。

(3)don编程扩展阅读：

DRY原则特指在程序设计以及计算中避免重复代码，因为这样会降低灵活性、简洁性，并且可能导致代码之间的矛盾，DRY是Andy Hunt 和 Dave Thomas's 的《 The Pragmatic Programmer 》书中的核心原则。

参考资料：DRY原则--网络

㈣ 软件编程中高级语言有哪些

编程语言，被我们熟知的，分为2大类

低级语言，又分为汇编语言和机器语言（二进制码语言，只用0和1）

高级语言，一般用的字母符号数字编写

那么高级编程语言又分哪些呢？

请看：

C

#include<stdio.h>
intmain(void){
//yourcodegoeshere
return0;
}

C++

#include<iostream>
usingnamespacestd;
intmain(){
//yourcodegoeshere
return0;
}

C#

usingSystem;
publicclassTest
{
publicstaticvoidMain()
{
//yourcodegoeshere
}
}

Bash

#!/bin/bash
#yourcodegoeshere

Java

/*packagewhatever;//don'tplacepackagename!*/
importjava.util.*;
importjava.lang.*;
importjava.io.*;
/*Nameoftheclasshastobe"Main"onlyiftheclassispublic.*/
classIdeone
{
publicstaticvoidmain(String[]args)throwsjava.lang.Exception
{
//yourcodegoeshere
}
}

Javascript

importPackage(java.io);
importPackage(java.lang);
//yourcodegoeshere

Perl

#!/usr/bin/perl
#yourcodegoeshere

php

<?php
//yourcodegoeshere

python

#yourcodegoeshere

VB

ImportsSystem
PublicClassTest
PublicSharedSubMain()
'yourcodegoeshere
EndSub
EndClass

Groovy

classIdeone{
staticvoidmain(String[]args){
}
}

Ruby

#yourcodegoeshere

Scala

objectMainextendsApp{
//yourcodegoeshere
}

个人建议：最好从C或C++开始学。可以拓展Java或者Python学习，也推荐PHP。VB学了对Microsoft宏很有帮助，其余语言不是很推荐啊。

备注：有一种编程工具用拼图的方式拼出程序，叫做Scratch，初学者建议试一下我也是学了这个转C++的。但Scratch不是编程语言，切记。

㈤ Windows编程中怎样理解“Don't call me,I will call you.”

你想想鼠标事件和键盘事件是怎样的 那他又是怎样接收消息的? 既然 鼠标键盘有响应消息,那么同样的USB接口也是有的.当USB接口(也就是外设)插入了U盘,那么就像鼠标点击了 "确定" 按钮一样,那么肯定有类似的函数和响应机制了.

㈥ 关于编程风格

<<Effective C++ & More Effective C++>>和
<<代码大全>>两本都是好书，看了你就懂了。

编程风格可以理解成写程序的习惯，有好的习惯是成为高手的关键。

同时你会发现效率会比有一大堆坏习惯的人高很多很多。

㈦ 想学编程不知道怎么入门，从哪学起

通常学习编程一般是有目的的， 比如想做桌面程序开发， 想做web开发，想做app，想做命令行工具等。
但是假如只是想学习编程而已，没有明确的开发目的，想要锻炼自己的编程能力，那么我给出一些个人建议：
1 在linux下学习编程，比如可以安装debian的testing系统(因为使用简单)，从实用的角度考虑可以选择学习python语言，如果对计算机硬件很有兴趣的话可以选择c语言。
2 找一本不太厚的书，安静地坐下来慢慢研读，边读边动手，先把一门语言的基础语法学会。不要选择那种非常厚的大全类型。
3 有了一定的语法基础知识后，尝试写一些简单的命令行小程序，比如我高三时写过自动算24的程序，或者是一些简单的图形打印程序
做到这一步其实算是比较容易的，大概会花掉1到3个月的时间，下一步就是提高编程能力了
4 练习编程的基本技能，比如递归、搜索、字符串匹配等，学习如何评估一个程序的性能，比如你的程序是O(n) 还是O(log N)的。 如果你喜欢，还可以做一些online judge的题库，这会大大的提高编程能力。
5 多学习现有工具的使用，比如grep、find、 awk、ssh等众多的linux工具，学习使用现有工具就是在锻炼自己的编程能力，这也是非常重要的。
6 如果英文阅读能力不错，建议尽早开始阅读英文文档，比如使用man程序查看help，google搜索国外的资料
做到这一步，你已经是难得的开发人员了，只需要经过工作的磨练，就能成为月薪上万的抢手货。但是你应该还不满足吧？ 那么继续
7 学习一些编程理论知识，比如KISS原则，以及比KISS还重要的 Don't repeat yourself 原则。推荐阅读《unix编程艺术》、《程序员修炼之道》等类似书籍，同时不要忘了不断的锻炼自己使用新工具的能力，比如vim、make等，熟话说工欲善其事，大家都知道了
8 找准自己的方向，寻找适合自己的团队，在团队中发挥自己的优势。在工作中学会客观地思考问题，放弃你之前所学的教条主义，什么运行性能？用户体验？交互设计？牛逼的算法？这些都是你的绊脚石。 要学会根据自身情况灵活应变，懂得取舍，懂得衡量每一个决策的性价比，你的时间和金钱才是硬道理。

㈧ 有哪些和编程有关的经典语句

1. One man's constant is another man's variable.

2. Functions delay binding: data structures ince binding. Moral: Structure data late in the programming process.

3. Syntactic sugar causes cancer of the semi-colons.

4. Every program is a part of some other program and rarely fits.

5. If a program manipulates a large amount of data, it does so in a small number of ways.

6. Symmetry is a complexity recing concept (co-routines include sub-routines); seek it everywhere.

7. It is easier to write an incorrect program than understand a correct one.

8. A programming language is low level when its programs require attention to the irrelevant.

9. It is better to have 100 functions operate on one data structure than 10 functions on 10 data structures.

10. Get into a rut early: Do the same processes the same way. Accumulate idioms. Standardize. The only difference (!) between Shakespeare and you was the size of his idiom list - not the size of his vocabulary.

11. If you have a procere with 10 parameters, you probably missed some.

12. Recursion is the root of computation since it trades description for time.

13. If two people write exactly the same program, each should be put in micro-code and then they certainly won't be the same.

14. In the long run every program becomes rococo - then rubble.

15. Everything should be built top-down, except the first time.

16. Every program has (at least) two purposes: the one for which it was written and another for which it wasn't.

17. If a listener nods his head when you're explaining your program, wake him up.

18. A program without a loop and a structured variable isn't worth writing.

19. A language that doesn't affect the way you think about programming, is not worth knowing.

20. Wherever there is molarity there is the potential for misunderstanding: Hiding information implies a need to check communication.

21. Optimization hinders evolution.

22. A good system can't have a weak command language.

23. To understand a program you must become both the machine and the program.

24. Perhaps if we wrote programs from childhood on, as alts we'd be able to read them.

25. One can only display complex information in the mind. Like seeing, movement or flow or alteration of view is more important than the static picture, no matter how lovely.

26. There will always be things we wish to say in our programs that in all known languages can only be said poorly.

27. Once you understand how to write a program get someone else to write it.

28. Around computers it is difficult to find the correct unit of time to measure progress. Some cathedrals took a century to complete. Can you imagine the grandeur and scope of a program that would take as long?

29. For systems, the analogue of a face-lift is to add to the control graph an edge that creates a cycle, not just an additional node.

30. In programming, everything we do is a special case of something more general - and often we know it too quickly.

31. Simplicity does not precede complexity, but follows it.

32. Programmers are not to be measured by their ingenuity and their logic but by the completeness of their case analysis.

33. The 11th commandment was "Thou Shalt Compute" or "Thou Shalt Not Compute" - I forget which.

34. The string is a stark data structure and everywhere it is passed there is much plication of process. It is a perfect vehicle for hiding information.

35. Everyone can be taught to sculpt: Michelangelo would have had to be taught how not to. So it is with the great programmers.

36. The use of a program to prove the 4-color theorem will not change mathematics - it merely demonstrates that the theorem, a challenge for a century, is probably not important to mathematics.

37. The most important computer is the one that rages in our skulls and ever seeks that satisfactory external emulator. The standardization of real computers would be a disaster - and so it probably won't happen.

38. Structured Programming supports the law of the excluded muddle.

39. Re graphics: A picture is worth 10K words - but only those to describe the picture. Hardly any sets of 10K words can be adequately described with pictures.

40. There are two ways to write error-free programs; only the third one works.

41. Some programming languages manage to absorb change, but withstand progress.

42. You can measure a programmer's perspective by noting his attitude on the continuing vitality of FORTRAN.

43. In software systems it is often the early bird that makes the worm.

44. Sometimes I think the only universal in the computing field is the fetch-execute-cycle.

45. The goal of computation is the emulation of our synthetic abilities, not the understanding of our analytic ones.

46. Like punning, programming is a play on words.

47. As Will Rogers would have said, "There is no such thing as a free variable."

48. The best book on programming for the layman is "Alice in Wonderland"; but that's because it's the best book on anything for the layman.

49. Giving up on assembly language was the apple in our Garden of Eden: Languages whose use squanders machine cycles are sinful. The LISP machine now permits LISP programmers to abandon bra and fig-leaf.

50. When we understand knowledge-based systems, it will be as before - except our finger-tips will have been singed.

51. Bringing computers into the home won't change either one, but may revitalize the corner saloon.

52. Systems have sub-systems and sub-systems have sub-systems and so on ad infinitum - which is why we're always starting over.

53. So many good ideas are never heard from again once they embark in a voyage on the semantic gulf.

54. Beware of the Turing tar-pit in which everything is possible but nothing of interest is easy.

55. A LISP programmer knows the value of everything, but the cost of nothing.

56. Software is under a constant tension. Being symbolic it is arbitrarily perfectible; but also it is arbitrarily changeable.

57. It is easier to change the specification to fit the program than vice versa.

58. Fools ignore complexity. Pragmatists suffer it. Some can avoid it. Geniuses remove it.

59. In English every word can be verbed. Would that it were so in our programming languages.

60. Dana Scott is the Church of the Lattice-Way Saints.

61. In programming, as in everything else, to be in error is to be reborn.

62. In computing, invariants are ephemeral.

63. When we write programs that "learn", it turns out we do and they don't.

64. Often it is means that justify ends: Goals advance technique and technique survives even when goal structures crumble.

65. Make no mistake about it: Computers process numbers - not symbols. We measure our understanding (and control) by the extent to which we can arithmetize an activity.

66. Making something variable is easy. Controlling ration of constancy is the trick.

67. Think of all the psychic energy expended in seeking a fundamental distinction between "algorithm" and "program".

68. If we believe in data structures, we must believe in independent (hence simultaneous) processing. For why else would we collect items within a structure? Why do we tolerate languages that give us the one without the other?

69. In a 5 year period we get one superb programming language. Only we can't control when the 5 year period will begin.

70. Over the centuries the Indians developed sign language for communicating phenomena of interest. Programmers from different tribes (FORTRAN, LISP, ALGOL, SNOBOL, etc.) could use one that doesn't require them to carry a blackboard on their ponies.

71. Documentation is like term insurance: It satisfies because almost no one who subscribes to it depends on its benefits.

72. An adequate bootstrap is a contradiction in terms.

73. It is not a language's weaknesses but its strengths that control the gradient of its change: Alas, a language never escapes its embryonic sac.

74. It is possible that software is not like anything else, that it is meant to be discarded: that the whole point is to always see it as soap bubble?

75. Because of its vitality, the computing field is always in desperate need of new cliches: Banality soothes our nerves.

76. It is the user who should parameterize proceres, not their creators.

77. The cybernetic exchange between man, computer and algorithm is like a game of musical chairs: The frantic search for balance always leaves one of the three standing ill at ease.

㈨ 加工中心分层铣圆用宏程序怎么编程

关于宏程序编程，步骤细致复杂，要对宏程序有相当的了解。

举一个例题如下：

1、例如加工一个长半轴30，短半轴20一个椭圆，椭圆不是圆弧，所以我们不能用圆弧的方式来加椭圆，这里我们用一小段一小段的直线来拼接这个椭圆。

㈩ 为什么说面向对象编程和函数式编程

先从结构化编程说起

很久以前，软件开发的世界还是一片浑浑噩噩，不管开发什么软件都面临着复杂性这个问题，代码里面到处是goto语句，程序的流程随意跳转。众生写代码时，越写到后面越不知道自己写的是什么。这时候出现一位巨人，它就是结构化编程。

结构化编程的基本思想是：

有序地控制流程，即把程序的执行顺序限制为顺序、分支和循环这三种；
把共通的处理归结为例程（函数）。
结构化编程的好处是：

三大限制：大大降低了程序的自由度，减少了各种组合，使得程序不至于太过复杂。对于这一点，结构化编程的顺序、分支和循环可以实现一切算法，虽然降低了程序的复杂性和灵活性，但是程序的实现能力并没有降低。
例程（函数）：我们只需要知道过程（函数）的名字，而不需要知道过程的内部细节，即“黑盒化”。
虽然结构化解决了程序控制流的复杂问题，但程序里面不仅包括控制结构，还包括要处理的数据。随着处理数据的增加，程序的复杂性也会上升。这时候，面向对象编程来了！

面向对象的由来

“分别管理程序处理内容和处理数据对象所带来的复杂性”问题是，为了得到正确的结果，必须保持处理和数据的一致性，这在结构化编程中是非常困难的，解决这一问题的方案就是数据抽象技术。

数据抽象是数据和处理方法的结合。这便是最初“对象”一词的得来。面向对象编程也因此得名。

然后，从抽象原则来说，多个相同事物出现时，应该组合在一起，即DRY原则(Don't Repeat Yourself)，便又引出了类这一概念。

根据数据类型来进行合适的处理（调用合适的方法），本来就应该是编程语言这种工具应该完成的事。这便是多态的引出了。

而对于继承，大部分的观点是“继承是随着程序的结构化和抽象化自然进化而来的一种方式”。结构化和抽象化，意味着把共通部分提取出来生成父类的自底向上的方法。（如果继承是这样诞生的话，那么最初，有多个父类的多重继承就会成为主流，而实际上最初引入继承的Simula语言只提供单一继承。松本行弘认为继承的原本目的实际是逐步细化）