编程

提示的原话是什么？

看一下吧 这样写OK吧double cos(double x){ double a; double b = 1; double sum = 1 ; for (int i = 2 ; i <= 10 ; i++) { a = 1 ; for (int j = 1 ; j <= i ; j++) { b = b * x ; // 求次方 a = a * j ; // 求阶乘 } if (i % 2 == 0) { sum += (-( b / a)); } else { sum += (b / a); } } return sum;}

下面是代码，我测试过是对的，希望我的努力对你有帮助。#include<stdio.h>#include<math.h>/*求阶乘函数*/intjiecheng(intn){if(n<0){printf("错误的数字 ");return-1;}elseif(n==0||n==1){return1;}else{returnjiecheng(n-1)*n;}}/*自己写的cos函数*/doublemycos(doublex){inti=2;doublesum=1.0f;intk=-1;while(i<=10){sum+=k*pow(x,i)/jiecheng(i);//pow是math.h里的函数求x的i次方k=-k;i++;}returnsum;}voidmain(){doublex=3.0f;printf("%d ",jiecheng(2));//测试阶乘printf("%f ",mycos(x));printf("%f ",cos(x));//库函数里的cos函数用来对比}

http://www.cnblogs.com/scottckt/archive/2008/05/09/1189366.html

java写的，可行package ex1;import java.awt.BorderLayout;import java.awt.Color;import java.awt.Dimension;import java.awt.Font;import java.awt.GridLayout;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.text.DecimalFormat;import javax.swing.BorderFactory;import javax.swing.ButtonGroup;import javax.swing.JButton;import javax.swing.JCheckBoxMenuItem;import javax.swing.JFrame;import javax.swing.JMenu;import javax.swing.JMenuBar;import javax.swing.JMenuItem;import javax.swing.JPanel;import javax.swing.JRadioButtonMenuItem;import javax.swing.JTextField;public class Calcutor extends JFrame {private JTextField tf;private JPanel panel1, panel2, panel3, panel4;private JMenuBar myBar;private JMenu menu1, menu2, menu3;private JMenuItem editItem1, editItem2, help1, help2, help3;private JRadioButtonMenuItem seeItem1, seeItem2;//单选框private JCheckBoxMenuItem seeItem3;//复选框private ButtonGroup bgb;private String back;private boolean IfResult = true, flag = false;private String oper = "=";private double result = 0;private Num numActionListener;private DecimalFormat df;public Calcutor(){super("科学计算器");//设置标题栏df = new DecimalFormat("#.####");//保留四位小数this.setLayout(new BorderLayout(10, 5));panel1 = new JPanel(new GridLayout(1, 3, 10, 10));panel2 = new JPanel(new GridLayout(5, 6, 5, 5));//5行6列panel3 = new JPanel(new GridLayout(5, 1, 5, 5));panel4 = new JPanel(new BorderLayout(5, 5));/*** 菜单栏*/myBar = new JMenuBar();menu1 = new JMenu("编辑(E)");menu2 = new JMenu("查看(V)");menu3 = new JMenu("帮助(H)");menu1.setFont(new Font("宋体", Font.PLAIN, 12));menu2.setFont(new Font("宋体", Font.PLAIN, 12));menu3.setFont(new Font("宋体", Font.PLAIN, 12));/*** 编辑栏*/editItem1 = new JMenuItem("复制(C) Ctrl+C");editItem2 = new JMenuItem("粘贴(P) Ctrl+V");editItem1.setFont(new Font("宋体",Font.PLAIN,12));editItem2.setFont(new Font("宋体",Font.PLAIN,12));/*** 查看栏*/seeItem1 = new JRadioButtonMenuItem("科学型(T)");seeItem2 = new JRadioButtonMenuItem("标准型(S)");seeItem3 = new JCheckBoxMenuItem("数字分组(I)");seeItem1.setFont(new Font("宋体",Font.PLAIN,12));seeItem2.setFont(new Font("宋体",Font.PLAIN,12));seeItem3.setFont(new Font("宋体",Font.PLAIN,12));/*** 帮助栏*/help1 = new JMenuItem("帮助主题(H)");help2 = new JMenuItem("关于计算器(A)");help1.setFont(new Font("宋体",Font.PLAIN,12));help2.setFont(new Font("宋体",Font.PLAIN,12));bgb = new ButtonGroup();//选项组menu1.add(editItem1);menu1.add(editItem2);menu2.add(seeItem1);menu2.add(seeItem2);menu2.addSeparator();//添加一条分割线menu2.add(seeItem3);menu3.add(help1);menu3.addSeparator();//添加一条分割线menu3.add(help2);myBar.add(menu1);myBar.add(menu2);myBar.add(menu3);this.setJMenuBar(myBar);numActionListener = new Num();//实现数字监听/*** 文本域，即为计算器的屏幕显示区域*/tf = new JTextField();tf.setEditable(false);//文本区域不可编辑tf.setBackground(Color.white);//文本区域的背景色tf.setHorizontalAlignment(JTextField.RIGHT);//文字右对齐tf.setText("0");tf.setBorder(BorderFactory.createLoweredBevelBorder());init();//对计算器进行初始化}/*** 初始化操作* 添加按钮*/private void init(){addButton(panel1, "Backspace", new Clear(), Color.red);addButton(panel1, "CE", new Clear(), Color.red);addButton(panel1, "C", new Clear(), Color.red);addButton(panel2, "1/x", new Signs(), Color.magenta);addButton(panel2, "log", new Signs(), Color.magenta);addButton(panel2, "7", numActionListener, Color.blue);addButton(panel2, "8", numActionListener, Color.blue);addButton(panel2, "9", numActionListener, Color.blue);addButton(panel2, "÷", new Signs(), Color.red);addButton(panel2, "n!", new Signs(), Color.magenta);addButton(panel2, "sqrt", new Signs(), Color.magenta);addButton(panel2, "4", numActionListener, Color.blue);addButton(panel2, "5", numActionListener, Color.blue);addButton(panel2, "6", numActionListener, Color.blue);addButton(panel2, "×", new Signs(), Color.red);addButton(panel2, "sin", new Signs(), Color.magenta);addButton(panel2, "x^2", new Signs(), Color.magenta);addButton(panel2, "1", numActionListener, Color.blue);addButton(panel2, "2", numActionListener, Color.blue);addButton(panel2, "3", numActionListener, Color.blue);addButton(panel2, "-", new Signs(), Color.red);addButton(panel2, "cos", new Signs(), Color.magenta);addButton(panel2, "x^3", new Signs(), Color.magenta);addButton(panel2, "0", numActionListener, Color.blue);addButton(panel2, "-/+", new Clear(), Color.blue);addButton(panel2, ".", new Dot(), Color.blue);addButton(panel2, "+", new Signs(), Color.red);addButton(panel2, "tan", new Signs(), Color.magenta);addButton(panel2, "%", new Signs(), Color.magenta);addButton(panel2, "π", numActionListener, Color.orange);addButton(panel2, "e", numActionListener, Color.orange);addButton(panel2, "′″", new Signs(), Color.orange);addButton(panel2, "=", new Signs(), Color.red);JButton btns = new JButton("计算器");btns.setBorder(BorderFactory.createLoweredBevelBorder());btns.setEnabled(false);//按钮不可操作btns.setPreferredSize(new Dimension(20, 20));panel3.add(btns);//加入按钮addButton(panel3, "MC", null, Color.red);addButton(panel3, "MR", null, Color.red);addButton(panel3, "MS", null, Color.red);addButton(panel3, "M+", null, Color.red);panel4.add(panel1, BorderLayout.NORTH);panel4.add(panel2, BorderLayout.CENTER);this.add(tf, BorderLayout.NORTH);this.add(panel3, BorderLayout.WEST);this.add(panel4);pack();this.setResizable(false);//窗口不可改变大小this.setLocation(300, 200);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}/*** 统一设置按钮的的使用方式* @param panel* @param name* @param action* @param color*/private void addButton(JPanel panel, String name, ActionListener action, Color color){JButton bt = new JButton(name);panel.add(bt);//在面板上增加按钮bt.setForeground(color);//设置前景（字体）颜色bt.addActionListener(action);//增加监听事件}/*** 计算器的基础操作（+ - × ÷）* @param x*/private void getResult (double x){if(oper == "+"){result += x;}else if(oper == "-"){result -= x;}else if(oper == "×"){result *= x;}else if(oper == "÷"){result /= x;}else if(oper == "="){result = x;}tf.setText(df.format(result));}/*** 运算符号的事件监听*/class Signs implements ActionListener{public void actionPerformed(ActionEvent e) {/** 用ActionEvent对象的getActionCommand()方法* 取得与引发事件对象相关的字符串*/String str = e.getActionCommand();/* sqrt求平方根 */if(str.equals("sqrt")){double i = Double.parseDouble(tf.getText());if(i>=0){/** String.valueOf() 转换为字符串* df.format() 按要求保留四位小数* Math.sqrt() 求算数平方根*/tf.setText(String.valueOf(df.format(Math.sqrt(i))));}else{tf.setText("负数不能开平方根");}}/* log求常用对数 */else if(str.equals("log")){double i = Double.parseDouble(tf.getText());if(i>0){tf.setText(String.valueOf(df.format(Math.log(i))));}else{tf.setText("负数不能求对数");}}/* %求百分比 */else if(str.equals("%")){tf.setText(df.format(Double.parseDouble(tf.getText()) / 100));}/* 1/x求倒数 */else if(str.equals("1/x")){if(Double.parseDouble(tf.getText()) == 0){tf.setText("除数不能为零");}else{tf.setText(df.format(1 / Double.parseDouble(tf.getText())));}}/* sin求正弦函数 */else if(str.equals("sin")){double i = Double.parseDouble(tf.getText());tf.setText(String.valueOf(df.format(Math.sin(i))));}/* cos求余弦函数 */else if(str.equals("cos")){double i = Double.parseDouble(tf.getText());tf.setText(String.valueOf(df.format(Math.cos(i))));}/* tan求正切函数 */else if(str.equals("tan")){double i = Double.parseDouble(tf.getText());tf.setText(String.valueOf(df.format(Math.tan(i))));}/* n!求阶乘 */else if(str.equals("n!")){double i = Double.parseDouble(tf.getText());if((i%2==0)||(i%2==1))//判断为整数放进行阶乘操作{int j = (int)i;//强制类型转换int result=1;for(int k=1;k<=j;k++)result *= k;tf.setText(String.valueOf(result));}else{tf.setText("无法进行阶乘");}}/* x^2求平方 */else if(str.equals("x^2")){double i = Double.parseDouble(tf.getText());tf.setText(String.valueOf(df.format(i*i)));}/* x^3求立方 */else if(str.equals("x^3")){double i = Double.parseDouble(tf.getText());tf.setText(String.valueOf(df.format(i*i*i)));}/* ′″角度转换 *//*** 将角度值转换成弧度值，方便三角函数的计算*/else if(str.equals("′″")){double i = Double.parseDouble(tf.getText());tf.setText(String.valueOf(i/180*Math.PI));}else{if(flag){IfResult = false;}if(IfResult){oper = str;}else{getResult(Double.parseDouble(tf.getText()));oper = str;IfResult = true;}}}}/*** 清除按钮的事件监听*/class Clear implements ActionListener{public void actionPerformed(ActionEvent e) {/** 用ActionEvent对象的getActionCommand()方法* 取得与引发事件对象相关的字符串*/String str = e.getActionCommand();if(str == "C"){tf.setText("0");IfResult = true;result = 0;}else if(str == "-/+"){double i = 0 - Double.parseDouble(tf.getText().trim());tf.setText(df.format(i));}else if(str == "Backspace"){if(Double.parseDouble(tf.getText()) > 0){if(tf.getText().length() > 1){tf.setText(tf.getText().substring(0, tf.getText().length() - 1));//使用退格删除最后一位字符}else{tf.setText("0");IfResult = true;}}else{if(tf.getText().length() > 2){tf.setText(tf.getText().substring(0, tf.getText().length() - 1));}else{tf.setText("0");IfResult = true;}}}else if(str == "CE"){tf.setText("0");IfResult = true;}}}/*** 数字输入的事件监听*/class Num implements ActionListener{public void actionPerformed(ActionEvent e) {String str = e.getActionCommand();if(IfResult){tf.setText("");IfResult = false;}if(str=="π"){tf.setText(String.valueOf(Math.PI));}else if(str=="e"){tf.setText(String.valueOf(Math.E));}else{tf.setText(tf.getText().trim() + str);if(tf.getText().equals("0")){tf.setText("0");IfResult = true;flag = true;}}}}/*** 小数点的事件监听*/class Dot implements ActionListener{public void actionPerformed(ActionEvent e) {IfResult = false;if(tf.getText().trim().indexOf(".") == -1){tf.setText(tf.getText() + ".");}}}/*** main方法*/public static void main(String[] args) {new Calcutor().setVisible(true);}}

解法用到的基本思想就是回溯，树的深度为最深为4，树的判断分支为 加减乘除，对不满足条件的解进行剪枝（即当前结果>=24）,当到达递归边界（即树的深度为四时）时，即判断当前的结果是否符合条件（=24），符合即找到解，否则继续进行。参考代码如下：#include<iostream>#include<math.h>using namespace std;const double MIN=1E-6;void Print(int *Rank,double *FourNum){for(int i=0;i<4;i++)cout<<FourNum[Rank[i]]<<" ";cout<<endl;}void Calculate_24(int *Rank,int *FourNum,char *Oper,int i,int j,int k,bool &def){double res=0;switch(i){case 0:res=FourNum[Rank[0]]+FourNum[Rank[1]];break;case 1:res=FourNum[Rank[0]]-FourNum[Rank[1]];break;case 2:res=FourNum[Rank[0]]*FourNum[Rank[1]];break;case 3:res=FourNum[Rank[0]]/FourNum[Rank[1]];break;}switch(j){case 0:res=res+FourNum[Rank[2]];break;case 1:res=res-FourNum[Rank[2]];break;case 2:res=res*FourNum[Rank[2]];break;case 3:res=res/FourNum[Rank[2]];break;}switch(k){case 0:res=res+FourNum[Rank[3]];break;case 1:res=res-FourNum[Rank[3]];break;case 2:res=res*FourNum[Rank[3]];break;case 3:res=res/FourNum[Rank[3]];break;}if(fabs(res-24)>MIN)return;else{def=true;for(int num=1;num<=7;num++){switch(num){case 1:cout<<FourNum[Rank[0]];break;case 3:cout<<FourNum[Rank[1]];break;case 5:cout<<FourNum[Rank[2]];break;case 7:cout<<FourNum[Rank[3]];break;case 2:cout<<Oper[i];break;case 4:cout<<Oper[j];break;case 6:cout<<Oper[k];break;}}cout<<endl;}}void SearchTree(int Depth,int *Rank,int *FourNum,char *Oper,bool &def){int i,j,k;if(Depth==4){for(i=0;i<4;i++)for(j=0;j<4;j++)for(k=0;k<4;k++)Calculate_24(Rank,FourNum,Oper,i,j,k,def);}else{for(i=0;i<4;i++){int Remember=0;for(j=0;j<Depth;j++){if(Rank[j]==i)Remember=1;}if(Remember)continue;Rank[Depth]=i;SearchTree(Depth+1,Rank,FourNum,Oper,def);}}}int main(){int a[4],b[4],time;char c[4]={"+","-","*","/"};bool def=false;cin>>time;while(time--){for(int i=0;i<4;i++)//输入测试数据cin>>a[i];cout<<"所有可能的结果："<<endl;SearchTree(0,b,a,c,def);if(def==false)cout<<"No"<<endl;}return 0;}

在这个执行计算的函数中，只定义了三个形参的类型，但是却没有定义接收实参值的实际变量。而在下面定义的两个整型变量和一个字符变量都没有能够获得值，（原本它们应该是从形式参数表中接受初始值的）另外，这个函数在执行的过程中直接输出计算的结果，但是最后的返回值却是写了返回0，那么这个返回的0就会在主函数中调用时被直接输出，也就是说输出一个0。下面已经把这个程序做了修改，请查阅修改后的源代码和运行的结果。另外，这个程序没有对除数为零做出检测，除非要能够确保输入的除数是不等于0的。#include <iostream>using namespace std;int evaluate(int n1,int n2,char oper){ if(oper="+") return n1+n2; else if(oper="-") return n1-n2; else if(oper="*") return n1*n2; else if(oper="/") return n1/n2; else if(oper="%") return n1%n2;}int main(){ int num1,num2; char oper; cin>>num1>>num2>>oper; cout<<num1<<oper<<num2<<"="<<evaluate(num1,num2,oper)<<endl;return 0;}

你能告诉我这4个有什么作用吗？写个数学例子我看看，然后写功能……

改正一楼的二个地方就是，#include <stdio.h>void main(){int n1,n2,result; /*result代表结果*/char oper;printf("请输入两个数: ");scanf("%d%d",&n1,&n2);fflush(stdin)/*此处清除键盘缓冲区，否则结果是错的*/printf(" 请输入运算");/*此处是printf书写错误*/scanf("%c",&oper);switch(oper){case "+":result=n1+n2;break;case "-":result=n1-n2;break;case "*":result=n1*n2;break;case "/":result=n1/n2;break;}printf(" %d %c %d = %d ",n1,oper,n2,result);}

void那个函数说明画一条分界线，类似于----------------分割线，其实在switch之前，c1c2等等结果已经被计算出来，后来输入oper，只是用switch匹配，看oper到底和case中哪个相等，就输出哪个结果啊~

多范式，就是多种编程方法的意思。有哪些编程方法呢？目前说来，有面向过程，面向对象，泛型，函数式四种程序设计方法。

安装刚接触Pillow的朋友先来看一下Pillow的安装方法，在这里我们以Mac OS环境为例： （1）、使用 pip 安装 Python 库。pip 是 Python 的包管理工具，安装后就可以直接在命令行一站式地安装/管理各种库了（pip 文档）。$ wget http://pypi.python.org/packages/source/p/pip/pip-0.7.2.tar.gz$ tar xzf pip-0.7.2.tar.gz$ cd pip-0.7.2$ python setup.py install（2）、使用 pip 下载获取 Pillow：$ pip install pillow（3）、安装过程中命令行出现错误提示：”error: command ‘clang" failed with exit status 1”。上网查阅，发现需要通过 Xcode 更新 Command Line Tool。于是打开 Xcode->Preferences->Downloads-Components选项卡。咦？竟然没了 Command Line Tools。再查，发现 Xcode 5 以上现在需要用命令行安装：$ xcode-select —install系统会弹出安装命令行工具的提示，点击安装即可。此时再 pip install pillow，就安装成功了。pip freeze 命令查看已经安装的 Python 包，Pillow 已经乖乖躺那儿了。好了，下面开始进入教程~Image类Pillow中最重要的类就是Image，该类存在于同名的模块中。可以通过以下几种方式实例化：从文件中读取图片，处理其他图片得到，或者直接创建一个图片。使用Image模块中的open函数打开一张图片：>>> from PIL import Image>>> im = Image.open("lena.ppm")如果打开成功，返回一个Image对象，可以通过对象属性检查文件内容>>> from __future__ import print_function>>> print(im.format, im.size, im.mode)PPM (512, 512) RGBformat属性定义了图像的格式，如果图像不是从文件打开的，那么该属性值为None；size属性是一个tuple，表示图像的宽和高（单位为像素）；mode属性为表示图像的模式，常用的模式为：L为灰度图，RGB为真彩色，CMYK为pre-press图像。如果文件不能打开，则抛出IOError异常。当有一个Image对象时，可以用Image类的各个方法进行处理和操作图像，例如显示图片：>>> im.show()ps：标准版本的show()方法不是很有效率，因为它先将图像保存为一个临时文件，然后使用xv进行显示。如果没有安装xv，该函数甚至不能工作。但是该方法非常便于debug和test。（windows中应该调用默认图片查看器打开）读写图片Pillow库支持相当多的图片格式。直接使用Image模块中的open()函数读取图片，而不必先处理图片的格式，Pillow库自动根据文件决定格式。Image模块中的save()函数可以保存图片，除非你指定文件格式，那么文件名中的扩展名用来指定文件格式。图片转成jpg格式from __future__ import print_functionimport os, sysfrom PIL import Imagefor infile in sys.argv[1:]: f, e = os.path.splitext(infile) outfile = f + ".jpg" if infile != outfile: try: Image.open(infile).save(outfile) except IOError: print("cannot convert", infile)save函数的第二个参数可以用来指定图片格式，如果文件名中没有给出一个标准的图像格式，那么第二个参数是必须的。创建缩略图from __future__ import print_functionimport os, sysfrom PIL import Imagesize = (128, 128)for infile in sys.argv[1:]: outfile = os.path.splitext(infile)[0] + ".thumbnail" if infile != outfile: try: im = Image.open(infile) im.thumbnail(size) im.save(outfile, "JPEG") except IOError: print("cannot create thumbnail for", infile)必须指出的是除非必须，Pillow不会解码或raster数据。当你打开一个文件，Pillow通过文件头确定文件格式，大小，mode等数据，余下数据直到需要时才处理。这意味着打开文件非常快，与文件大小和压缩格式无关。下面的程序用来快速确定图片属性：确定图片属性from __future__ import print_functionimport sysfrom PIL import Imagefor infile in sys.argv[1:]: try: with Image.open(infile) as im: print(infile, im.format, "%dx%d" % im.size, im.mode) except IOError: pass裁剪、粘贴、与合并图片Image类包含还多操作图片区域的方法。如crop()方法可以从图片中提取一个子矩形从图片中复制子图像box = im.copy() #直接复制图像box = (100, 100, 400, 400)region = im.crop(box)区域由4-tuple决定，该tuple中信息为(left, upper, right, lower)。 Pillow左边系统的原点（0，0）为图片的左上角。坐标中的数字单位为像素点，所以上例中截取的图片大小为300*300像素^2。处理子图，粘贴回原图region = region.transpose(Image.ROTATE_180)im.paste(region, box)将子图paste回原图时，子图的region必须和给定box的region吻合。该region不能超过原图。而原图和region的mode不需要匹配，Pillow会自动处理。另一个例子Rolling an imagedef roll(image, delta): "Roll an image sideways" image = image.copy() #复制图像 xsize, ysize = image.size delta = delta % xsize if delta == 0: return image part1 = image.crop((0, 0, delta, ysize)) part2 = image.crop((delta, 0, xsize, ysize)) image.paste(part2, (0, 0, xsize-delta, ysize)) image.paste(part1, (xsize-delta, 0, xsize, ysize)) return image分离和合并通道r, g, b = im.split()im = Image.merge("RGB", (b, g, r))对于单通道图片，split()返回图像本身。为了处理单通道图片，必须先将图片转成RGB。几何变换Image类有resize()、rotate()和transpose()、transform()方法进行几何变换。简单几何变换out = im.resize((128, 128))out = im.rotate(45) # 顺时针角度表示置换图像out = im.transpose(Image.FLIP_LEFT_RIGHT)out = im.transpose(Image.FLIP_TOP_BOTTOM)out = im.transpose(Image.ROTATE_90)out = im.transpose(Image.ROTATE_180)out = im.transpose(Image.ROTATE_270)transpose()和象的rotate()没有性能差别。更通用的图像变换方法可以使用transform()模式转换convert()方法模式转换im = Image.open("lena.ppm").convert("L")图像增强Filter ImageFilter模块包含很多预定义的增强filters，通过filter()方法使用应用filtersfrom PIL import ImageFilterout = im.filter(ImageFilter.DETAIL) 像素点处理point()方法通过一个函数或者查询表对图像中的像素点进行处理（例如对比度操作）。像素点变换# multiply each pixel by 1.2out = im.point(lambda i: i * 1.2)上述方法可以利用简单的表达式进行图像处理，通过组合point()和paste()还能选择性地处理图片的某一区域。处理单独通道# split the image into individual bandssource = im.split()R, G, B = 0, 1, 2# select regions where red is less than 100mask = source[R].point(lambda i: i < 100 and 255)# process the green bandout = source[G].point(lambda i: i * 0.7)# paste the processed band back, but only where red was < 100source[G].paste(out, None, mask)# build a new multiband imageim = Image.merge(im.mode, source)注意到创建mask的语句：mask = source[R].point(lambda i: i < 100 and 255)该句可以用下句表示imout = im.point(lambda i: expression and 255)如果expression为假则返回expression的值为0（因为and语句已经可以得出结果了），否则返回255。（mask参数用法：当为0时，保留当前值，255为使用paste进来的值，中间则用于transparency效果）高级图片增强对其他高级图片增强，应该使用ImageEnhance模块 。一旦有一个Image对象，应用ImageEnhance对象就能快速地进行设置。 可以使用以下方法调整对比度、亮度、色平衡和锐利度。图像增强from PIL import ImageEnhanceenh = ImageEnhance.Contrast(im)enh.enhance(1.3).show("30% more contrast")动态图Pillow支持一些动态图片的格式如FLI/FLC，GIF和其他一些处于实验阶段的格式。TIFF文件同样可以包含数帧图像。当读取动态图时，PIL自动读取动态图的第一帧，可以使用seek和tell方法读取不同郑from PIL import Imageim = Image.open("animation.gif")im.seek(1) # skip to the second frametry: while 1: im.seek(im.tell()+1) # do something to imexcept EOFError: pass # end of sequence当读取到最后一帧时，Pillow抛出EOFError异常。当前版本只允许seek到下一郑为了倒回之前，必须重新打开文件。或者可以使用下述迭代器类动态图迭代器类class ImageSequence: def __init__(self, im): self.im = im def __getitem__(self, ix): try: if ix: self.im.seek(ix) return self.im except EOFError: raise IndexError # end of sequencefor frame in ImageSequence(im): # ...do something to frame...Postscript PrintingPillow允许通过Postscript Printer在图片上添加images、text、graphics。Drawing Postscriptfrom PIL import Imagefrom PIL import PSDrawim = Image.open("lena.ppm")title = "lena"box = (1*72, 2*72, 7*72, 10*72) # in pointsps = PSDraw.PSDraw() # default is sys.stdoutps.begin_document(title)# draw the image (75 dpi)ps.image(box, im, 75)ps.rectangle(box)# draw centered titleps.setfont("HelveticaNarrow-Bold", 36)w, h, b = ps.textsize(title)ps.text((4*72-w/2, 1*72-h), title)ps.end_document()更多读取图片方法之前说到Image模块的open()函数已经足够日常使用。该函数的参数也可以是一个文件对象。从string中读取import StringIOim = Image.open(StringIO.StringIO(buffer))从tar文件中读取from PIL import TarIOfp = TarIO.TarIO("Imaging.tar", "Imaging/test/lena.ppm")im = Image.open(fp)草稿模式draft()方法允许在不读取文件内容的情况下尽可能（可能不会完全等于给定的参数）地将图片转成给定模式和大小，这在生成缩略图的时候非常有效（速度要求比质量高的场合）。draft模式from __future__ import print_functionim = Image.open(file)print("original =", im.mode, im.size)im.draft("L", (100, 100))print("draft =", im.mode, im.size)

我也是即将毕业的大学生,学的是计算机,就我对现在就业市场的了解,你学到什么程度并不重要,只要你会基本语法掌握其精髓,有很强的自学能力和逻辑思维能力,一般笔试只考些语言和数据结构基础问题,面试不会问你专业知识,一般是考你逻辑思维和问些对工作看法等问题.

学习QT编程,QT做了简单的系统抽象,不光能在windows上跑,还可以跨其他平台,语法是纯c/c++

工具-->自定义-->命令-->新菜单-->将右边的“新菜单”拖到EXCEL菜单上产生菜单（可自命名） 同样将在左边选择“宏”-->右边选择“自定义按钮”拖到“新菜单”下（可自命名) 然后与宏对接

随着机器人产业与人工智能的不断发展，未来很多基本工作将会被机器替代，社会正在进入人机共融的新时代。编程思维作为未来一种重要的思维方式，将变得越来越重要。机器人编程主要目的就是为了让孩子可以尽早地接触和了解，并学习如何运用一些技术手段来解决实际问题。从3岁到18岁，在各年龄阶段，各编程语言学习阶段，编程编程机器人都已经有涉及。

拿起手机，你第一件事会做什么？上QQ？追番？吃鸡？玩MC？还是来一盘王者荣耀？现在，你又多了一件事打开【编程猫Nemo】手机上的编程APP，口袋里的源码世界初次进入编程猫Nemo，会看到编程猫为大家准备的新手礼带你熟悉一些基本操作熟悉完毕后跟网页版一样，点击“创作”就可以开始你的编（表）程（演）！那相比网页版，手机版的创作工具有什么特色呢？【手机版特色功能介绍】1、作品数据在作品库页面可以查看每一个作品的具体数据，统计了作品的角色数量以及使用的积木行数（如图，《重力飞机大战》使用了4个角色，34行积木代码）2、手机特色积木专为手机制作的触发事件积木丰富你的游戏开启方式3、独特交互模式我们将角色界面与编程界面分屏通过点击“界面切换”按钮，即可轻松切换角色界面与编程界面这是由于手机屏幕相比电脑屏幕来说比较小分屏后可以方便角色的管理、舞台效果展示以及编程区域最大化。4、云端保存从网页版到手机版，大家依旧会担心一个问题花了好多心血完成的作品丢！失！了！怎！么！办！特色云端功能，当你退出作品创作回到作品库时作品会自动上传到云端备份如果没有上传云端的作品在右下角会有“云上传”图标提示比如说复制出来的作品副本-花了好多心血完成的作品丢！失！了！怎！么！办！特色云端功能，当你退出作品创作回到作品库时作品会自动上传到云端备份如果没有上传云端的作品在右下角会有“云上传”图标提示比如说复制出来的作品副本5、一键分享创作完成后可以将作品直接分享到多个渠道也可以复制链接分享给自己的小伙伴（超小声：在稍微远一点点的将来会有发布功能的！）不过，由于手机版与网页版的机制不同有其自身的特性及功能所以手机与网页的作品不会互通编程猫Nemo是你的另一片创作天地你可以在这里创作出一个又一个的手游随时随地（马路上不可以啊喂，要注意安全啊喂）打开手机即可开始你的创作编程猫Nemo已经在苹果AppStore里等你召唤啦！苹果手机扫描二维码即可下载- 本文出自顺义在线，原文地址：http://www.shunyiqu.com/thread-696160-1-1.html

spike适合7岁以上的孩子学习。SPIKEPrime的创新积木设计比MindstromsEV3更便于搭建，但还是主要基于乐高机械类的连接方式，同时Scratch编程界面也需要孩子有初步的文字阅读能力。所以建议7岁以上的孩子会比较适合。1、少儿编程就是针对少年、儿童的编程学习，通常是指在青少年阶段进行计算机编程能力的教育。2、不像成人编程，少儿编程≠敲代码，不需要像程序员那样，对着屏幕敲击键盘、枯燥地编写一行行晦涩难懂的英文代码，而是以少年能接受的方式，训练孩子的逻辑思维、计算思维、创新思维及问题解决能力，提升综合素养和实力。

1. 下载要升级到的版本的编程猫的源码编程器。 2. 使用要升级到的版本的编程猫的源码编程器覆盖安装到旧版的就可以了。

显然元音才是难点啊 ，不知道怎么个判断。。读元音才是元音，才加es，可惜不知道那个字母会读元音。

1）MCGS策略构件VB接口程序设计MCGS策略构件的实现方法和原理与标准VB的ActiveDLL完全一致，但MCGS规定了一套接口规范，只有遵守这些接口规范的ActiveDLL才能用作MCGS的策略构件。MCGS策略构件必须具有如下4个接口：SvrMenuCommand：组态时调用，执行菜单命令；SvrStgySetOperator：组态时调用，设置构件的属性；SvrStgyRunOperator：运行时调用，执行构件的功能；SvrCheck：组态中，编译查错时调用。开发MCGS功能构件的过程，实际就是根据功能构件特性和含义完成4个接口功能的编程过程。2）VB与Matlab的实时通信VB中调用Matlab文件的方法有很多，本文选用COM组件技术实现VB与Matlab的实时数据交换、处理。利用Matlab6．5中的MatlabCOMBuilder技术将前面编写的模糊自适应PID算法M文件转换成

在设置参数的时候选择绝对或增量

有些可以在刀具设置里可以设置，或者更改后处理

Reactor 和Rxjava是Reactive Programming范例的一个具体实现，可以概括为： 作为反应式编程方向的第一步，Microsoft在.NET生态系统中创建了Reactive Extensions（Rx）库。然后RxJava在JVM上实现了响应式编程。随着时间的推移，通过Reactive Streams工作出现了Java的标准化，这一规范定义了JVM上的反应库的一组接口和交互规则。它的接口已经在父类Flow下集成到Java 9中。 另外Java 8还引入了Stream，它旨在有效地处理数据流（包括原始类型），这些数据流可以在没有延迟或很少延迟的情况下访问。它是基于拉的，只能使用一次，缺少与时间相关的操作，并且可以执行并行计算，但无法指定要使用的线程池。但是它还没有设计用于处理延迟操作，例如I / O操作。其所不支持的特性就是Reactor或RxJava等Reactive API的用武之地。 Reactor 或 Rxjava等反应性API也提供Java 8 Stream等运算符，但它们更适用于任何流序列（不仅仅是集合），并允许定义一个转换操作的管道，该管道将应用于通过它的数据，这要归功于方便的流畅API和使用lambdas。它们旨在处理同步或异步操作，并允许您缓冲，合并，连接或对数据应用各种转换。 首先考虑一下，为什么需要这样的异步反应式编程库？现代应用程序可以支持大量并发用户，即使现代硬件的功能不断提高，现代软件的性能仍然是一个关键问题。 人们可以通过两种方式来提高系统的能力： 通常，Java开发人员使用阻塞代码编写程序。这种做法很好，直到出现性能瓶颈，此时需要引入额外的线程。但是，资源利用率的这种扩展会很快引入争用和并发问题。 更糟糕的是，会导致浪费资源。一旦程序涉及一些延迟（特别是I / O，例如数据库请求或网络调用），资源就会被浪费，因为线程（或许多线程）现在处于空闲状态，等待数据。 所以并行化方法不是灵丹妙药，获得硬件的全部功能是必要的。 第二种方法，寻求现有资源的更高的使用率，可以解决资源浪费问题。通过编写异步，非阻塞代码，您可以使用相同的底层资源将执行切换到另一个活动任务，然后在异步处理完成后返回到当前线程进行继续处理。 但是如何在JVM上生成异步代码？ Java提供了两种异步编程模型： 但是上面两种方法都有局限性。首先多个callback难以组合在一起，很快导致代码难以阅读以及难以维护（称为“Callback Hell”）: 考虑下面一个例子：在用户的UI上展示用户喜欢的top 5个商品的详细信息，如果不存在的话则调用推荐服务获取5个；这个功能的实现需要三个服务支持：一个是获取用户喜欢的商品的ID的接口（userService.getFavorites），第二个是获取商品详情信息接口（favoriteService.getDetails），第三个是推荐商品与商品详情的服务（suggestionService.getSuggestions），基于callback模式实现上面功能代码如下：如上为了实现该功能，我们写了很多代码，使用了大量callback,这些代码比较晦涩难懂,并且存在代码重复，下面我们使用Reactor来实现等价的功能：future相比callback要好一些，但尽管CompletableFuture在Java 8上进行了改进，但它们仍然表现不佳。一起编排多个future是可行但是不容易的，它们不支持延迟计算（比如rxjava中的defer操作）和高级错误处理，例如下面例子。考虑另外一个例子：首先我们获取一个id列表，然后根据id分别获取对应的name和统计数据，然后组合每个id对应的name和统计数据为一个新的数据，最后输出所有组合对的值，下面我们使用CompletableFuture来实现这个功能，以便保证整个过程是异步的，并且每个id对应的处理是并发的：Reactor本身提供了更多的开箱即用的操作符，使用Reactor来实现上面功能代码如下:如上代码使用reactor方式编写的代码相比使用CompletableFuture实现相同功能来说，更简洁，更通俗易懂。 可组合性，指的是编排多个异步任务的能力，使用先前任务的结果作为后续任务的输入或以fork-join方式执行多个任务。 编排任务的能力与代码的可读性和可维护性紧密相关。随着异步过程层数量和复杂性的增加，能够编写和读取代码变得越来越困难。正如我们所看到的，callback模型很简单，但其主要缺点之一是，对于复杂的处理，您需要从回调执行回调，本身嵌套在另一个回调中，依此类推。那个混乱被称为Callback Hell，正如你可以猜到的（或者从经验中得知），这样的代码很难回归并推理。 Reactor提供了丰富的组合选项，其中代码反映了抽象过程的组织，并且所有内容通常都保持在同一级别（嵌套最小化）。 原材料可以经历各种转换和其他中间步骤，或者是将中间元素聚集在一起形成较大装配线的一部分。如果在装配线中某一点出现堵塞，受影响的工作站可向上游发出信号以限制原材料的向下流动。 虽然Reactive Streams规范根本没有指定运算符，但Reactor或者rxjava等反应库的最佳附加值之一是它们提供的丰富的运算符。这些涉及很多方面，从简单的转换和过滤到复杂的编排和错误处理。 在Reactor中，当您编写Publisher链时，默认情况下数据不会启动。相反，您可以创建异步过程的抽象描述（这可以帮助重用和组合）。 上游传播信号也用于实现背压，我们在装配线中将其描述为当工作站比上游工作站处理速度慢时向上游线路发送的反馈信号。 这将推模型转换为推拉式混合模式，如果上游生产了很多元素，则下游可以从上游拉出n个元素。但是如果元素没有准备好，就会在上游生产出元素后推数据到下游。

1 Reactor 框架概述POCO 中的 Reactor 框架是基于 Reactor 设计模式进行设计的。其中由 Handler 将某 Socket 产生的事件，发送到指定的对象的方法上，作为回调。2 光说不练假把式PoechantReactorServer 类，基本与 PoechantTCPServer： class PoechantReactorServer: public ServerApplication { public: PoechantServer() {} //: _helpRequested(false) {} ~PoechantServer() {} protected: void initialize(Application& self) { loadConfiguration(); ServerApplication::initialize(self); } void uninitialize() { ServerApplication::uninitialize(); } int main(const std::vector& args) { // … return Application::EXIT_OK; } }PoechantServiceHandler 类定义如下。 class PoechantServiceHandler { public: PoechantServiceHandler(StreamSocket& socket, SocketReactor& reactor)； ~PoechantServiceHandler(); void onReadable(const AutoPtr& pNf); void onShutdown(const AutoPtr& pNf); private: enum { BUFFER_SIZE = 1024 }; StreamSocket _socket; SocketReactor& _reactor; char *_pBuffer; }；PoechantServiceHandler 实现： PoechantServiceHandler::PoechantServiceHandler(StreamSocket& socket, SocketReactor& reactor) :_socket(socket), _reactor(reactor), _pBuffer(new char[BUFFER_SIZE]) { Application& app = Application::instance(); app.logger().information("Connection from" + socket.peerAddress().toString()); _reactor.addEventHandler(_socket, NObserver(*this, &PoechantServiceHandler::onReadable)); _reactor.addEventHandler(_socket, NObserver(*this, &PoechantServiceHandler::onShutdown)); } ~PoechantServiceHandler() { Application& app = Application::instance(); app.logger().information("Disconnecting " + _socket.peerAddress().toString()); _reactor.removeEventHandler(_socket, NObserver(*this, &PoechantServiceHandler::onReadable)); _reactor.removeEventHandler(_socket, NObserver(*this, &PoechantServiceHandler::onShutdown)); delete [] _pBuffer; } void onReadable(const AutoPtr& pNf) { // Receive data from StreamSocket int n = _socket.receiveBytes(_pBuffer, BUFFER_SIZE); // Send data back the client if (n > 0) _socket.sendBytes(_pBuffer, n); else delete this; } // When ShutdownNotification is detected, this method will be invoked. void onShutdown(const AutoPtr& pNf) { delete this; }启动： int main(const std::vector& args) { unsigned short port = (unsigned short) config().getInt("PoechantReactor.port", 12345); ServerSocket serverSocket(port); SocketReactor reactor; SocketAcceptor acceptor(serverSocket, reactor); reactor.run(); waitForTerminationRequest(); reactor.stop(); return Application::EXIT_OK; } int main(int argc, char **argv) { return PoechantServer().run(argc, argv); }3 Clinet 测试代码同《POCO库中文编程参考指南（10）如何使用TCPServer框架？

JAVA_HOME路径要到bin里面吧

三角形的求边公式：(x1-x2)2+(y1-y2)2再开方。

目前讲：很少了；企业内部可能有；软件开发基本不用该软件了。其该软件的魅力还在！可锻炼一下[基本功]。

>>f=inline("x^2-x-2");>>[c,err,yc]=bisect(f,0,3,0.01)c=2.0010err=0.0059yc=0.0029-----------%使用二分法求解上面超越方程%下面是二分法的函数文件,你直接设置输入参数就可以了function[c,err,yc]=bisect(f,a,b,delta)%Input-fisthefunction%-aandbaretheleftandrightendpoints%-deltaisthetolerance%Output-cisthezero%-yc=f(c)%-erristheerrorestimateforc%IffisdefinedasanM-filefunctionusethe@notation%call[c,err,yc]=bisect(@f,a,b,delta).%Iffisdefinedasananonymousfunctionusethe%call[c,err,yc]=bisect(f,a,b,delta).%NUMERICALMETHODS:MatlabPrograms%(c)2004byJohnH.MathewsandKurtisD.Fink%ComplementarySoftwaretoaccompanythetextbook:%NUMERICALMETHODS:UsingMatlab,FourthEdition%ISBN:0-13-065248-2%Prentice-HallPub.Inc.%OneLakeStreet%UpperSaddleRiver,NJ07458ya=f(a);yb=f(b);ifya*yb>0,return,endmax1=1+round((log(b-a)-log(delta))/log(2));fork=1:max1c=(a+b)/2;yc=f(c);ifyc==0a=c;b=c;elseifyb*yc>0b=c;yb=yc;elsea=c;ya=yc;endifb-a<delta,break,endendc=(a+b)/2;err=abs(b-a);yc=f(c);

while 0=<input_num<=100:

Y0变为ON并保持该状态，即使X0的常开触点断开，它也仍然保持ON状态。三菱编程常见的意思如下：SET：置位指令，使操作保持ON的指令。 RST：复位指令，使操作保持OFF的指令。 SET指令可用于Y，M和S，RST指令可用于复位Y，M，S，T，C，或将字元件D，V和Z清零。 如果图1中X0的常开触点接通，Y0变为ON并保持该状态，即使X0的常开触点断开，它也仍然保持ON状态。当X1的常开触点闭合时，Y0变为OFF并保持该状态，即使X1的常开触点断开，它也仍然保持OFF状态(见图1中的波形图)。 对同一编程元件，可多次使用SET和RST指令，最后一次执行的指令将决定当前的状态。RST指令可将数据寄存器D、变址寄存器Z租V的内容清零，RST指令还用来复位积算定时器T246～T255和计数器。 SET、RST指令的功能与数字电路中R–S触发器的功能相似，SET与RST指令之间可以插入别的程序。如果它们之间没有别的程序，最后的指令有效。 图2中X0的常开触点接通时，积算定时器T246．复位，X3的常开触点接通时，计数器C200复位，它们的当前值被清0，常开触点断开，常闭触点闭合。 在任何情况下，RST指令都优先执行。计数器处于复位状态时，输入的计数脉冲不起作用。

在三菱的plc编程中，bin是变换指令，将源元件中的bcd数据转换成二进制数据送到目标元件中。bint2k1y100即表示将k1y100里的数据，转为二进制送到t2里。

中考+20分

添加能量源项是比较简单的。Define-boundaryconditions---在zone中选择添加源项的区域，点击set----选择sourceterms选项（注意在该项前打钩）---其中energ中用来添加能量源项，可以添加常数项或udf编写的

Python常用的web框架推荐：1、FlaskFlask是一个轻量级的web框架，可以快速构建web应用程序。Flask的优点之一是其灵活性，因为它允许您在自己的代码项目中实现所需的定制。Flask适合小型项目和初学者，因为它的学习曲线较低。2、DjangoDjango是一个功能强大的Web框架，适合大型项目。 它包括ORM，模板引擎，管理站点和完整的认证系统等内置功能。 Django的一个独特的优点是它的强大的管理站点，允许您在不编写任何HTML的情况下构建一个完整的后台管理应用程序。 Django具有强大的社区支持，因此可以轻松找到有用的示例代码和插件。3、PyramidPyramid是一个可伸缩的Web框架，旨在处理大型应用程序。 Pyramid具有高度定制的模式，使其在Web应用程序的多种应用中具有广泛的适用性。 Pyramid的一个重要优势是其可扩展性，允许您随着项目的不断发展进行逐步构建。4、BottleBottle是另一个轻量级的Web框架，适用于小型项目。 Bottle提供了一个快速而灵活的方法来构建Web应用程序，但它并不提供预定义的模板。 如果您需要快速启动一个小型Web应用程序并掌握它的完全控制权，则Bottle是一个不错的选择。5、TornadoTornado是一个基于异步事件循环的Web框架，适用于需要高性能的应用程序。 Tornado提供了一种非阻塞的方式来处理Web请求和其他事件，这可以大大提高应用程序的吞吐量。Tornado还包括内置的Web服务器，可以轻松扩展。总的来讲，Python在web开发领域有许多优秀的框架和工具可供选择。灵活性和可扩展性是Python web开发的明显优势，而这些优势正吸引着越来越多的开发者转向Python。

三种专门用于线程同步的机制:POSIX信号量,互斥量和条件变量. 在Linux上信号量API有两组,一组是System V IPC信号量,即PV操作,另外就是POSIX信号量,POSIX信号量的名字都是以sem_开头. phshared参数指定信号量的类型,若其值为0,就表示这个信号量是当前进程的局部信号量,否则该信号量可以在多个进程之间共享.value值指定信号量的初始值,一般与下面的sem_wait函数相对应. 其中比较重要的函数sem_wait函数会以原子操作的方式将信号量的值减一,如果信号量的值为零,则sem_wait将会阻塞,信号量的值可以在sem_init函数中的value初始化;sem_trywait函数是sem_wait的非阻塞版本;sem_post函数将以原子的操作对信号量加一,当信号量的值大于0时,其他正在调用sem_wait等待信号量的线程将被唤醒. 这些函数成功时返回0,失败则返回-1并设置errno. 生产者消费者模型: 生产者对应一个信号量:sem_t producer; 消费者对应一个信号量:sem_t customer; sem_init(&producer,2)----生产者拥有资源,可以工作; sem_init(&customer,0)----消费者没有资源,阻塞; 在访问公共资源前对互斥量设置（加锁），确保同一时间只有一个线程访问数据，在访问完成后再释放（解锁）互斥量. 互斥锁的运行方式:串行访问共享资源; 信号量的运行方式:并行访问共享资源; 互斥量用pthread_mutex_t数据类型表示，在使用互斥量之前，必须使用pthread_mutex_init函数对它进行初始化，注意，使用完毕后需调用pthread_mutex_destroy. pthread_mutex_init用于初始化互斥锁，mutexattr用于指定互斥锁的属性，若为NULL，则表示默认属性。除了用这个函数初始化互斥所外，还可以用如下方式初始化：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER。 pthread_mutex_destroy用于销毁互斥锁，以释放占用的内核资源，销毁一个已经加锁的互斥锁将导致不可预期的后果。 pthread_mutex_lock以原子操作给一个互斥锁加锁。如果目标互斥锁已经被加锁，则pthread_mutex_lock则被阻塞，直到该互斥锁占有者把它给解锁. pthread_mutex_trylock和pthread_mutex_lock类似，不过它始终立即返回，而不论被操作的互斥锁是否加锁，是pthread_mutex_lock的非阻塞版本.当目标互斥锁未被加锁时，pthread_mutex_trylock进行加锁操作；否则将返回EBUSY错误码。注意：这里讨论的pthread_mutex_lock和pthread_mutex_trylock是针对普通锁而言的，对于其他类型的锁，这两个加锁函数会有不同的行为. pthread_mutex_unlock以原子操作方式给一个互斥锁进行解锁操作。如果此时有其他线程正在等待这个互斥锁，则这些线程中的一个将获得它. 三个打印机轮流打印: 输出结果: 如果说互斥锁是用于同步线程对共享数据的访问的话,那么条件变量就是用于在线程之间同步共享数据的值.条件变量提供了一种线程之间通信的机制:当某个共享数据达到某个值时,唤醒等待这个共享数据的线程. 条件变量会在条件不满足的情况下阻塞线程.且条件变量和互斥量一起使用，允许线程以无竞争的方式等待特定的条件发生. 其中pthread_cond_broadcast函数以广播的形式唤醒所有等待目标条件变量的线程,pthread_cond_signal函数用于唤醒一个等待目标条件变量线程.但有时候我们可能需要唤醒一个固定的线程,可以通过间接的方法实现:定义一个能够唯一标识目标线程的全局变量,在唤醒等待条件变量的线程前先设置该变量为目标线程,然后采用广播的方式唤醒所有等待的线程,这些线程被唤醒之后都检查该变量以判断是否是自己. 采用条件变量+互斥锁实现生产者消费者模型: 运行结果: 阻塞队列+生产者消费者 运行结果:

直接用原子锁吧

gcc吧

施耐德PLC主要有以下系列：NEZA PLC（TSX08系列）、Quantum PLC（140系列）、Micro PLC（TSX37系列）、Premium PLC（TSX 57系列）。施耐德的工业机械自动化控制器PLC系列以及各系列编程平台如下：已经淘汰的产品线：1、NEZA PLC（TSX08系列）NEZA系列是一个丰富功能的小型PLC，性能价格比高，体积小，通用性强。新一代的手持式编程器中文掌上电脑PL707WinCE，支持中文界面，无论是编程，监控，调试还是现场操作，都十分方便。2、 Premium PLC（TSX 57系列）中型机架，CPU功能强，速度快，内存大。丰富的联网通讯功能，紧凑灵活的开关量和多种模拟量模块：特种模块、高速计数模块轴控制模块、步进控制模块、通信模块及称重模块，编程环境与Micro PLC 相同。3、Quantum PLC（140系列）组态方便，维护简单，结构和模块的灵活选择。通过在世界范围内的上万的装机量，已被无数种应用证明满足各种应用需求。性能出色的处理器，先进的IEC方式编程，支持各种网络。4、Micro PLC（TSX37系列）紧凑型机架，体积小，功能强，配置灵活，价格低，适合中国市场特点强大的CPU功能，速度快，内存大，集成LED显示窗，并可多任务运行。紧凑的I/O模块结构，开关量I/O容量大(可达248点)。模拟量I/O点数多(可达41点)，功能强(有40KHz的高速计数模块和集成的10KHz硬件计数和500Hz软件计数等)。最新的产品线：1、Twido，小型PLC，可完成一般的自动化任务，比西门子S7-200性能稍弱，编程平台是TwidoSoft或TwidoSuite；2、M218，小型PLC，可完成一般的自动化任务，比西门子S7-200性能稍弱，编程平台是SoMachine；3、M238，面向OEM自动化的小型专用PLC，可完成较复杂的OEM自动化任务，跟西门子S7-200性能接近，编程平台是SoMachine；4、M258，中型PLC，跟西门子S7-300性能接近，但结构有所差异，更接近于倍加莱、倍福、万可的产品，编程平台是SoMachine；5、M340，中型PLC，跟西门子S7-300性能接近，编程平台是Unitry；6、Premium，中型PLC，跟西门子S7-300性能接近，新的编程平台是Unitry，原来是PL7 Pro；7、Quantumn，大型PLC，跟西门子S7-400性能接近，新的编程平台是Unitry，原来是Concept；扩展资料：PLC控制系统，Programmable Logic Controller，可编程逻辑控制器，专为工业生产设计的一种数字运算操作的电子装置。它采用一类可编程的存储器，用于其内部存储程序，执行逻辑运算，顺序控制，定时，计数与算术操作等面向用户的指令，并通过数字或模拟式输入/输出控制各种类型的机械或生产过程，是工业控制的核心部分。目前，PLC控制器在国内外已广泛应用于钢铁、石油、化工、电力、建材、机械制造、汽车、轻纺、交通运输、环保及文化娱乐等各个行业。参考资料来源：施耐德中国网站—PLC

Rust 是一种日益流行的编程语言，被视为硬件接口的最佳选择。通常会将其与 C 的抽象级别相比较。本文介绍了 Rust 如何通过多种方式处理按位运算，并提供了既安全又易于使用的解决方案。 在系统编程领域，你可能经常需要编写硬件驱动程序或直接与内存映射设备进行交互，而这些交互几乎总是通过硬件提供的内存映射寄存器来完成的。通常，你通过对某些固定宽度的数字类型进行按位运算来与这些寄存器进行交互。 例如，假设一个 8 位寄存器具有三个字段： 字段名称下方的数字规定了该字段在寄存器中使用的位。要启用该寄存器，你将写入值 1（以二进制表示为 0000_0001）来设置 Enabled 字段的位。但是，通常情况下，你也不想干扰寄存器中的现有配置。假设你要在设备上启用中断功能，但也要确保设备保持启用状态。为此，必须将 Interrupt 字段的值与 Enabled 字段的值结合起来。你可以通过按位操作来做到这一点： 通过将 1 和 2（1 左移一位得到）进行“或”（|）运算得到二进制值 0000_0011 。你可以将其写入寄存器，使其保持启用状态，但也启用中断功能。 你的头脑中要记住很多事情，特别是当你要在一个完整的系统上和可能有数百个之多的寄存器打交道时。在实践上，你可以使用助记符来执行此操作，助记符可跟踪字段在寄存器中的位置以及字段的宽度（即它的上边界是什么） 下面是这些助记符之一的示例。它们是 C 语言的宏，用右侧的代码替换它们的出现的地方。这是上面列出的寄存器的简写。＆ 的左侧是该字段的起始位置，而右侧则限制该字段所占的位： 然后，你可以使用这些来抽象化寄存器值的操作，如下所示： 这就是现在的做法。实际上，这就是大多数驱动程序在 Linux 内核中的使用方式。 有没有更好的办法？如果能够基于对现代编程语言研究得出新的类型系统，就可能能够获得安全性和可表达性的好处。也就是说，如何使用更丰富、更具表现力的类型系统来使此过程更安全、更持久？ 继续用上面的寄存器作为例子： 你想如何用 Rust 类型来表示它呢？ 你将以类似的方式开始，为每个字段的偏移定义常量（即，距最低有效位有多远）及其掩码。掩码是一个值，其二进制表示形式可用于更新或读取寄存器内部的字段： 最后，你将使用一个 Register 类型，该类型会封装一个与你的寄存器宽度匹配的数字类型。 Register 具有 update 函数，可使用给定字段来更新寄存器： 使用 Rust，你可以使用数据结构来表示字段，将它们与特定的寄存器联系起来，并在与硬件交互时提供简洁明了的工效。这个例子使用了 Rust 提供的最基本的功能。无论如何，添加的结构都会减轻上述 C 示例中的某些晦涩的地方。现在，字段是个带有名字的事物，而不是从模糊的按位运算符派生而来的数字，并且寄存器是具有状态的类型 —— 这在硬件上多了一层抽象。 用 Rust 重写的第一个版本很好，但是并不理想。你必须记住要带上掩码和偏移量，并且要手工进行临时计算，这容易出错。人类不擅长精确且重复的任务 —— 我们往往会感到疲劳或失去专注力，这会导致错误。一次一个寄存器地手动记录掩码和偏移量几乎可以肯定会以糟糕的结局而告终。这是最好留给机器的任务。 其次，从结构上进行思考：如果有一种方法可以让字段的类型携带掩码和偏移信息呢？如果可以在编译时就发现硬件寄存器的访问和交互的实现代码中存在错误，而不是在运行时才发现，该怎么办？也许你可以依靠一种在编译时解决问题的常用策略，例如类型。 你可以使用 typenum 来修改前面的示例，该库在类型级别提供数字和算术。在这里，你将使用掩码和偏移量对 Field 类型进行参数化，使其可用于任何 Field 实例，而无需将其包括在调用处： 现在，当重新访问 Field 的构造函数时，你可以忽略掩码和偏移量参数，因为类型中包含该信息： 看起来不错，但是……如果你在给定的值是否适合该字段方面犯了错误，会发生什么？考虑一个简单的输入错误，你在其中放置了 10 而不是 1： 在上面的代码中，预期结果是什么？好吧，代码会将启用位设置为 0，因为 10＆1 = 0。那真不幸；最好在尝试写入之前知道你要写入字段的值是否适合该字段。事实上，我认为截掉错误字段值的高位是一种 1未定义的行为（哈）。 如何以一般方式检查字段的值是否适合其规定的位置？需要更多类型级别的数字！ 你可以在 Field 中添加 Width 参数，并使用它来验证给定的值是否适合该字段： 现在，只有给定值适合时，你才能构造一个 Field ！否则，你将得到 None 信号，该信号指示发生了错误，而不是截掉该值的高位并静默写入意外的值。 但是请注意，这将在运行时环境中引发错误。但是，我们事先知道我们想写入的值，还记得吗？鉴于此，我们可以教编译器完全拒绝具有无效字段值的程序 —— 我们不必等到运行它！ 这次，你将向 new 的新实现 new_checked 中添加一个特征绑定（where 子句），该函数要求输入值小于或等于给定字段用 Width 所能容纳的最大可能值： 只有拥有此属性的数字才实现此特征，因此，如果使用不适合的数字，它将无法编译。让我们看一看！ new_checked 将无法生成一个程序，因为该字段的值有错误的高位。你的输入错误不会在运行时环境中才爆炸，因为你永远无法获得一个可以运行的工件。 就使内存映射的硬件进行交互的安全性而言，你已经接近 Rust 的极致。但是，你在 C 的第一个示例中所写的内容比最终得到的一锅粥的类型参数更简洁。当你谈论潜在可能有数百甚至数千个寄存器时，这样做是否容易处理？ 早些时候，我认为手工计算掩码有问题，但我又做了同样有问题的事情 —— 尽管是在类型级别。虽然使用这种方法很不错，但要达到编写任何代码的地步，则需要大量样板和手动转录（我在这里谈论的是类型的同义词）。 我们的团队想要像 TockOS mmio 寄存器 之类的东西，而以最少的手动转录生成类型安全的实现。我们得出的结果是一个宏，该宏生成必要的样板以获得类似 Tock 的 API 以及基于类型的边界检查。要使用它，请写下一些有关寄存器的信息，其字段、宽度和偏移量以及可选的 枚举 类的值（你应该为字段可能具有的值赋予“含义”）： 由此，你可以生成寄存器和字段类型，如上例所示，其中索引：Width、Mask 和 Offset 是从一个字段定义的 WIDTH 和 OFFSET 部分的输入值派生的。另外，请注意，所有这些数字都是 “类型数字”；它们将直接进入你的 Field 定义！ 生成的代码通过为寄存器及字段指定名称来为寄存器及其相关字段提供名称空间。这很绕口，看起来是这样的： 生成的 API 包含名义上期望的读取和写入的原语，以获取原始寄存器的值，但它也有办法获取单个字段的值、执行集合操作以及确定是否设置了任何（或全部）位集合的方法。你可以阅读 完整生成的 API 上的文档。 将这些定义用于实际设备会是什么样？代码中是否会充斥着类型参数，从而掩盖了视图中的实际逻辑？ 不会！通过使用类型同义词和类型推断，你实际上根本不必考虑程序的类型层面部分。你可以直接与硬件交互，并自动获得与边界相关的保证。 一旦到位，使用这些寄存器就像 read() 和 modify() 一样简单： 当我们使用运行时值时，我们使用如前所述的 选项 。这里我使用的是 unwrap，但是在一个输入未知的真实程序中，你可能想检查一下从新调用中返回的 某些东西 ： 1 2 根据你的个人痛苦忍耐程度，你可能已经注意到这些错误几乎是无法理解的。看一下我所说的不那么微妙的提醒： expected struct typenum::B0, found struct typenum::B1 部分是有意义的，但是 typenum::UInt<typenum::UInt, typenum::UInt... 到底是什么呢？好吧，typenum 将数字表示为二进制 cons 单元！像这样的错误使操作变得很困难，尤其是当你将多个这些类型级别的数字限制在狭窄的范围内时，你很难知道它在说哪个数字。当然，除非你一眼就能将巴洛克式二进制表示形式转换为十进制表示形式。 在第 U100 次试图从这个混乱中破译出某些含义之后，我们的一个队友简直《 疯了，地狱了，不要再忍受了(Mad As Hell And Wasn"t Going To Take It Anymore)》，并做了一个小工具 tnfilt，从这种命名空间的二进制 cons 单元的痛苦中解脱出来。tnfilt 将 cons 单元格式的表示法替换为可让人看懂的十进制数字。我们认为其他人也会遇到类似的困难，所以我们分享了 tnfilt 。你可以像这样使用它： 它将上面的输出转换为如下所示： 现在这才有意义！ 当在软件与硬件进行交互时，普遍使用内存映射寄存器，并且有无数种方法来描述这些交互，每种方法在易用性和安全性上都有不同的权衡。我们发现使用类型级编程来取得内存映射寄存器交互的编译时检查可以为我们提供制作更安全软件的必要信息。该代码可在 bounded-registers crate（Rust 包）中找到。 我们的团队从安全性较高的一面开始，然后尝试找出如何将易用性滑块移近易用端。从这些雄心壮志中，“边界寄存器”就诞生了，我们在 Auxon 公司的冒险中遇到内存映射设备的任何时候都可以使用它。 此内容最初发布在 Auxon Engineering 博客 上，并经许可进行编辑和重新发布。 via: https://opensource.com/article/20/1/c-vs-rust-abstractions 作者： Dan Pittman 选题： lujun9972 译者： wxy 校对： wxy

那么，让我们来看看为什么 Rust 可能是目前最好的编程语言的一些原因！ 使用 Rust 的一个巨大优势是越来越受欢迎，在过去的几年里，这种语言一直在快速增长，为什么这很重要？嗯，这意味着 Rust 不是一门垂死的语言（至少现在），这意味着这种语言的发展是一致的，这也可能意味着未来这种语言会有更多的工作！ Rust 的另一个巨大优势是常量更新，这种语言一直在更新，为什么这很重要？这实质上意味着有开发人员在不断地使用/开发这种语言，这也意味着我们也可以获得语言的不断改进/功能！ 你有它！你打算使用 Rust 吗？我很想听听你对此的看法！ 非常感谢您的阅读！

自己继承Control 重写lable 封装click事件处理逻辑

1、用前台javascript脚本，如onclick="this.style.backgroundColor="red";"2、用后台C#代码，如Label1.BackgroundColor=Color.Red;

#include<stdio.h>#include<string.h>int main(){ int i,j,t,n,table[10][2]; char hline[64],vline[64]; scanf("%d",&t); for(i=0;i<t;i++) scanf("%d%d",&table[i][0],&table[i][1]); for(i=0;i<t;i++) { n=table[i][1]*3+1; memset(hline,"-",n); hline[n]=""; for(j=0;j<table[i][1];j++) { vline[3*j]="|"; vline[3*j+1]=" "; vline[3*j+2]=" "; } vline[3*j]="|"; vline[3*j+1]=""; for(j=0;j<table[i][0];j++) { puts(hline); puts(vline); puts(vline); } puts(hline); } return 0;}

Long ll_Width, ll_Heightll_Width = this.WorkSpaceWidth()ll_Height = this.WorkspaceHeight()p_1.Resize(ll_Width - p_1.X - ii_WindowBorder, ll_Height - p_1.Y - i_WindowBorder)

面向函数。根据查询jax的官网得知：jax用函数式编程是在设计的时候备好的，jax面向函数，使用函数编程可以使得算法准确，因此jax用函数式编程。

KX-TDA200软件的调试,包含哪些元素？ 球有哪些性质？ 球面上两点的

1，要理解计算机能认识的只有0和1.并且没有二义性。2，离散数学 ，理解计算机是怎样像人类大脑一样工作的，能用人脑的思维模式转换成计算机模式。理解宇宙存在就是能量波，这些波都可以用各种传感器转换成模拟的电信号，数字化以后变成0和1让计算机识别，有佛教的不二法则。3，汇编语言 学会0和1的助记符编程。4，数据结构，计算机的智慧。5，机电一体化，具备模拟信号转变数字信号的能力。6，理解这此以后计算机是怎样模拟人脑做事的就可以了。你能懂我现在说的就可以了。你如果顿悟。上面的课程不用学了。云端都有各种语言的样本，和结果，你只要模块用就行，计算机语言都是模块化的。站在四维空间看三维空间。7，你想用什么语言编程，就去云端找。完成一个计算机编程就这么简单。照葫芦画瓢，看您需要什么。希望您能顿悟。踩在前人肩膀看世界，您只要会搭积木，就能达到您的理想。共勉。谢谢！

// 服务器import java.io.*; import java.net.*; public class MyServer { public static void main(String[] args) throws IOException{ ServerSocket server=new ServerSocket(5678); while (true) { Socket client=server.accept(); BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream())); PrintWriter out=new PrintWriter(client.getOutputStream()); while(true){ String str=in.readLine(); System.out.println(str); out.println("has receive...."); out.flush(); if(str.equals("exit")) break; } client.close(); } } } // 客户端import java.net.*; import java.io.*; public class Client{ static Socket server; public static void main(String[] args)throws Exception{ server=new Socket(InetAddress.getLocalHost(),5678); BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream())); PrintWriter out=new PrintWriter(server.getOutputStream()); BufferedReader wt=new BufferedReader(new InputStreamReader(System.in)); while(true){ String str=wt.readLine(); out.println(str); out.flush(); if(str.equals("end")){ break; } System.out.println(in.readLine()); } server.close(); } }

已知某一局域网中若干台机器上的根目录下都存在同一个xml文件//看上去好像是说这些机器都是web服务器如果是这样的话，可以：使用.net 的WebRequest类进行遍历这些服务器,然后读取这个xml文件。另：可以直接使用xmldocument对象进行读取

out.println("test_outputs");后面加个out.flush();

从函数调用上来分析（msdn)：一旦完成了套接字的连接，应当将套接字关闭，并且释放其套接字句柄所占用的所有资源。真正释放一个已经打开的套接字句柄的资源直接调用closesocket即可，但要明白closesocket的调用可能会带来负面影响，具体的影响和如何调用有关，最明显的影响是数据丢失，因此一般都要在closesocket之前调用shutdown来关闭套接字。 shutdown:为了保证通信双方都能够收到应用程序发出的所有数据，一个合格的应用程序的做法是通知接受双发都不在发送数据！这就是所谓的“正常关闭 ”套接字的方法，而这个方法就是由shutdown函数,传递给它的参数有SD_RECEIVE,SD_SEND,SD_BOTH三种，如果是 SD_RECEIVE就表示不允许再对此套接字调用接受函数。这对于协议层没有影响，另外对于tcp套接字来说，无论数据是在等候接受还是即将抵达，都要重置连接（注意对于udp协议来说，仍然接受并排列传入的数据，因此udp套接字而言shutdown毫无意义）。如果选择SE_SEND,则表示不允许再调用发送函数。对于tcp套接字来说，这意味着会在所有数据发送出并得到接受端确认后产生一个FIN包。如果指定SD_BOTH，答案不言而喻。 closesocket:对此函数的调用会释放套接字的描述，这个道理众所周知（凡是经常翻阅msdn的程序员），因此，调用此函数后，再是用此套接字就会发生调用失败，通常返回的错误是WSAENOTSOCK。此时与被closesocket的套接字描述符相关联的资源都会被释放，包括丢弃传输队列中的数据！！！！对于当前进程中的线程来讲，所有被关起的操作，或者是被挂起的重叠操作以及与其关联的任何事件，完成例程或完成端口的执行都将调用失败！另外 SO_LINGER标志还影响着closesocket的行为，但对于传统的socket程序，这里不加解释 因此可以可以看出shutdown对切断连接有着合理的完整性。 下面从tcp协议上来分析shutdown和closesocket的行为（behavior)：closesocket或shutdown(使用 SD_SEND当作参数时）,会向通信对方发出一个fin包，而此时套接字的状态会由ESTABLISHED变成FIN_WAIT_1，然后对方发送一个 ACK包作为回应，套接字又变成FIN_WAIT_2，如果对方也关闭了连接则对方会发出FIN，我方会回应一个ACK并将套接字置为 TIME_WAIT。因此可以看出closesocket,shutdown所进行的TCP行为是一样的，所不同的是函数部分，shutdown会确保 windows建立的数据传输队列中的数据不被丢失，而closesocket会冒然的抛弃所有的数据，因此如果你愿意closesocket完全可以取代shutdown,然而在数据交互十分复杂的网络协议程序中，最好还是shutdown稳妥一些！？有关TCP协议的连接原理清访问 http://www.rfc-editor.org第RFC793号文件

import java.awt.*;import java.awt.event.*;import java.io.*;import java.net.*;public class ChatClient extends Frame {Socket s = null;DataOutputStream dos = null;DataInputStream dis = null;private boolean bConnected = false;TextField tfTxt = new TextField();TextArea taContent = new TextArea();Thread tRecv = new Thread(new RecvThread()); public static void main(String[] args) {new ChatClient().launchFrame(); }public void launchFrame() {setLocation(400, 300);this.setSize(300, 300);add(tfTxt, BorderLayout.SOUTH);add(taContent, BorderLayout.NORTH);pack();this.addWindowListener(new WindowAdapter() {@Overridepublic void windowClosing(WindowEvent arg0) {disconnect();System.exit(0);}});tfTxt.addActionListener(new TFListener());setVisible(true);connect();tRecv.start();}public void connect() {try {s = new Socket("127.0.0.1", 8888);dos = new DataOutputStream(s.getOutputStream());dis = new DataInputStream(s.getInputStream());System.out.println("connected!");bConnected = true;} catch (UnknownHostException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}public void disconnect() {try {dos.close();dis.close();s.close();} catch (IOException e) {e.printStackTrace();}/*try {bConnected = false;tRecv.join();} catch(InterruptedException e) {e.printStackTrace();} finally {try {dos.close();dis.close();s.close();} catch (IOException e) {e.printStackTrace();}}*/}private class TFListener implements ActionListener {public void actionPerformed(ActionEvent e) {String str = tfTxt.getText().trim();//taContent.setText(str);tfTxt.setText("");try {//System.out.println(s);dos.writeUTF(str);dos.flush();//dos.close();} catch (IOException e1) {e1.printStackTrace();}}}private class RecvThread implements Runnable {public void run() {try {while(bConnected) {String str = dis.readUTF();//System.out.println(str);taContent.setText(taContent.getText() + str + " ");}} catch (SocketException e) {System.out.println("退出了，bye!");} catch (EOFException e) {System.out.println("推出了，bye - bye!");} catch (IOException e) {e.printStackTrace();} }}}import java.io.*;import java.net.*;import java.util.*;public class ChatServer {boolean started = false;ServerSocket ss = null;List<Client> clients = new ArrayList<Client>();public static void main(String[] args) {new ChatServer().start();}public void start() {try {ss = new ServerSocket(8888);started = true;} catch (BindException e) {System.out.println("端口使用中....");System.out.println("请关掉相关程序并重新运行服务器！");System.exit(0);} catch (IOException e) {e.printStackTrace();}try {while(started) {Socket s = ss.accept();Client c = new Client(s);System.out.println("a client connected!");new Thread(c).start();clients.add(c);//dis.close();}} catch (IOException e) {e.printStackTrace();} finally {try {ss.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}class Client implements Runnable {private Socket s;private DataInputStream dis = null;private DataOutputStream dos = null;private boolean bConnected = false;public Client(Socket s) {this.s = s;try {dis = new DataInputStream(s.getInputStream());dos = new DataOutputStream(s.getOutputStream());bConnected = true;} catch (IOException e) {e.printStackTrace();}}public void send(String str) {try {dos.writeUTF(str);} catch (IOException e) {clients.remove(this);System.out.println("对方退出了！我从List里面去掉了！");//e.printStackTrace();}}public void run() {try {while(bConnected) {String str = dis.readUTF();System.out.println(str);for(int i=0; i<clients.size(); i++) {Client c = clients.get(i);c.send(str);//System.out.println(" a string send !");}/*for(Iterator<Client> it = clients.iterator(); it.hasNext(); ) {Client c = it.next();c.send(str);}*//*Iterator<Client> it = clients.iterator();while(it.hasNext()) {Client c = it.next();c.send(str);}*/}} catch (EOFException e) {System.out.println("Client closed!");} catch (IOException e) {e.printStackTrace();} finally {try {if(dis != null) dis.close();if(dos != null) dos.close();if(s != null) {s.close();//s = null;}} catch (IOException e1) {e1.printStackTrace();}}}}}

首先，可以在客户端和服务器端协商一个传输协议，在这个传输协议中可以在数据包头增加一个字段，该字段描述后面数据的具体长度，这样在接收方就可以根据这个字段知道要分配多长的空间和什么时候结束。然后，网络传输的字节序都是确定的，都是大端序(Big-Endian)，因此不需要考虑大小端问题

实现方法 以及API 不同。运用的地方不同。当然主要取决去二者的各自特点。1)TCP是面向连接的传输控制协议，而UDP提供了无连接的数据报服务；（2）TCP具有高可靠性，确保传输数据的正确性，不出现丢失或乱序；UDP在传输数据前不建立连接，不对数据报进行检查与修改，无须等待对方的应答，所以会出现分组丢失、重复、乱序，应用程序需要负责传输可靠性方面的所有工作；（3）也正因为以上特征，UDP具有较好的实时性，工作效率较TCP协议高；（4）UDP段结构比TCP的段结构简单，因此网络开销也小。具体二种协议没有好坏，只有适合，有时候二者结合，比如QQ就是两种协议都有，比如组播通信的时候只能用udp

引入线程的目的是为了监听端口，如果只用一个单线程，当监听一个端口的时候 ，就不能响应其他事件，所以要用多线程来执行应用程序

//获取时间CString strTime;CTime st = CTime::GetCurrentTime();strTime = st.Format("%Y%m%d%H%M%S");//创建服务器端 WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested = MAKEWORD( 1, 1 ); err = WSAStartup( wVersionRequested, &wsaData ); if ( err != 0 ) { return; } if ( LOBYTE( wsaData.wVersion ) != 1 || HIBYTE( wsaData.wVersion ) != 1 ) { WSACleanup( ); return; } SOCKET sock = socket(AF_INET,SOCK_STREAM,0); int opt = 1; int len11 = sizeof(opt); setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(char*)&opt,len11); if (sock == INVALID_SOCKET) { // "初始化失败" ; closesocket(sock); return; } SOCKADDR_IN addrsrv; addrsrv.sin_family = AF_INET; addrsrv.sin_port = htons(6001); addrsrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY); if (bind(sock,(SOCKADDR*)&addrsrv,sizeof(SOCKADDR)) == SOCKET_ERROR) { // "绑定失败" closesocket(sock); return; } listen(sock,10);//客户端接收服务器连接char m_recvBuf[2000];memset(m_recvBuf, 0, 2000);while(TRUE){ SOCKET sNew = ::accept(sock, (SOCKADDR*)&addrRemote, &nAddrLen);//接收到客户端连接//发送时间 int hvsndlen = 0; int sndlen = 0; while ((len -hvsndlen) > 0) { sndlen = send(soc,(LPCTSTR)strTime +hvsndlen,len-hvsndlen,0); if (sndlen == SOCKET_ERROR) { return -1; } hvsndlen += sndlen; }}//把以上程序放入你的主程序中，应该可以运行。里面有CString类型，如果用不习惯，你可以把CTime 转换成其他类型

很高兴协助你完成朋友

bind函数的原型是int bind(SOCKET s, const sockaddr *addr, int namelen);第二个参数的类型是const sockaddr*，而不是sockaddr_in*。你传递的参数类型错误。

对于通信来说，不存在绝对的服务器和客户端，谁在等待别人来，谁就是服务器，谁主动去联系人，谁就是客户端。所以。你要想客户端接受消息，那在启动客户端的时候，在客户端程序里开始一个提供端口的Socket就可以了。ServerSocket serverSocket = new ServerSocket(5000);while (true) {final Socket socket = serverSocket.accept();new Thread() {Socket mySocket = socket;@Overridepublic void run() {try {System.out.println(mySocket);InputStream is = mySocket.getInputStream();byte[] bytes = new byte[1024];int n = is.read(bytes);System.out.println(new String(bytes, 0, n));OutputStream os = mySocket.getOutputStream();os.write(("server reply at time " + new Date().toString()).getBytes());mySocket.close();} catch (Exception e) {e.printStackTrace();}}}.start();}

无

更新完数据后调用下UpdateWindow();

你用异步socket接收的时候确实会出现这个情况而且是正常的。你可以自己在发送的数据前面加上一个数据头，比如一个结构体说明一下数据的长度之类的信息

Socket是套接字，跟IP绑定后，可以进行网络通信

//服务端server.c#include <stdio.h>#include <stdlib.h>#include <errno.h>#include <string.h>#include <sys/types.h>#include <netinet/in.h>#include <sys/socket.h>#include <sys/wait.h>#define SERVPORT 6000 /*服务器监听端口号 */#define BACKLOG 10 /* 最大同时连接请求数 */#define MAXDATASIZE 100main(){ char buf[MAXDATASIZE]; int sockfd,client_fd; /*sock_fd：监听socket；client_fd：数据传输socket */ struct sockaddr_in my_addr; /* 本机地址信息 */ struct sockaddr_in remote_addr; /* 客户端地址信息 */ if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket创建出错！"); exit(1); } my_addr.sin_family=AF_INET; my_addr.sin_port=htons(SERVPORT); my_addr.sin_addr.s_addr = INADDR_ANY; bzero(&(my_addr.sin_zero),8); if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) { perror("bind出错！"); exit(1); } if (listen(sockfd, BACKLOG) == -1) { perror("listen出错！"); exit(1); } while(1) { sin_size = sizeof(struct sockaddr_in); if ((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size)) == -1) { perror("accept出错"); continue; } printf("received a connection from %s ", inet_ntoa(remote_addr.sin_addr)); if (!fork()) { /* 子进程代码段 */ if ((recvbytes=recv(client_fd, buf, MAXDATASIZE, 0)) ==-1) { perror("recv出错！"); close(client_fd); exit(0); } buf[recvbytes] = ""; printf("from client Received: %s",buf); if (send(client_fd, "thanks! ", 8, 0) == -1) perror("send出错！"); close(client_fd); exit(0); } close(client_fd); }}//客户端client.c#include<stdio.h>#include <stdlib.h>#include <errno.h>#include <string.h>#include <netdb.h>#include <sys/types.h>#include <netinet/in.h>#include <sys/socket.h>#define SERVPORT 6000#define MAXDATASIZE 100main(int argc, char *argv[]){ int sockfd, recvbytes; char buf[MAXDATASIZE]; struct hostent *host; struct sockaddr_in serv_addr; if (argc < 2) { fprintf(stderr,"Please enter the server"s hostname! "); exit(1); } if((host=gethostbyname(argv[1]))==NULL) { herror("gethostbyname出错！"); exit(1); } if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket创建出错！"); exit(1); } serv_addr.sin_family=AF_INET; serv_addr.sin_port=htons(SERVPORT); serv_addr.sin_addr = *((struct in_addr *)host->h_addr); bzero(&(serv_addr.sin_zero),8); if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr)) == -1) { perror("connect出错！"); exit(1); }if (send(sockfd, "hello! ", 7, 0) == -1) { perror("send出错！"); exit(1); } if ((recvbytes=recv(sockfd, buf, MAXDATASIZE, 0)) ==-1) { perror("recv出错！"); exit(1); } buf[recvbytes] = ""; printf("Received: %s",buf); close(sockfd);}

顶我，我告诉你！gongtaikj@163.com

wVersionRequested = MAKEWORD( 1, 1 ); //将两个byte型合并成一个word型，一个在高8位(b)，一个在低8位(a) err = WSAStartup( wVersionRequested, &wsaData ); if ( LOBYTE( wsaData.wVersion ) != 1 || HIBYTE( wsaData.wVersion ) != 1 ) { WSACleanup( ); return; } //查找是否有可用的WinSock DLL/*****************上面的都是windows操作系统下的初始化工作******************************/SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0); //创建套接字addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);//设置服务器地址，INADDR_ANY表示任意地址，一般只有一个网卡，就是你本机上使用的那个地址addrSrv.sin_family=AF_INET; //地址协议族addrSrv.sin_port=htons(6000); //设置端口，htons()中h表示host,n表示net，本地字节要转换成网络字节，即host to net ，s表示shortbind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));// 绑定端口listen(sockSrv,5); //监听创建的套接字，最大连接数5

实现方法 以及API 不同。运用的地方不同。当然主要取决去二者的各自特点。1)TCP是面向连接的传输控制协议，而UDP提供了无连接的数据报服务；（2）TCP具有高可靠性，确保传输数据的正确性，不出现丢失或乱序；UDP在传输数据前不建立连接，不对数据报进行检查与修改，无须等待对方的应答，所以会出现分组丢失、重复、乱序，应用程序需要负责传输可靠性方面的所有工作；（3）也正因为以上特征，UDP具有较好的实时性，工作效率较TCP协议高；（4）UDP段结构比TCP的段结构简单，因此网络开销也小。具体二种协议没有好坏，只有适合，有时候二者结合，比如QQ就是两种协议都有，比如组播通信的时候只能用udp

下面是代码， socket就是绑定IP和端口后，并双方相互连接后，一般就是客户端 和服务器，利用sendto recvfrom 函数发送接收，这个流是字节数据，下面是udp发送接收数据的例子，可以看看，前面大部分代码都是初始化网络，绑定IP和端口 socket的初始化功能的，核心在sendto 和recvfrom //发送端程序#include <stdio.h>#include <winsock.h>int main(int argc, char* argv[]){ WSADATA wsaData; //指向WinSocket信息结构的指针 SOCKET sockListener; SOCKADDR_IN sin,saUdpServ; BOOL fBroadcast = TRUE; char sendBuff[1024]; int nSize; int ncount=0; if(WSAStartup(MAKEWORD( 1, 1 ), &wsaData )!=0)//进行WinSocket的初始化 { printf("Can"t initiates windows socket!Program stop. ");//初始化失败返回-1 return -1; } sockListener=socket(PF_INET,SOCK_DGRAM,0); setsockopt ( sockListener,SOL_SOCKET,SO_BROADCAST,(CHAR *)&fBroadcast,sizeof ( BOOL )); sin.sin_family = AF_INET; sin.sin_port = htons(0); sin.sin_addr.s_addr = htonl(INADDR_ANY); if(bind( sockListener, (SOCKADDR *)&sin, sizeof(sin))!=0) { printf("Can"t bind socket to local port!Program stop. ");//初始化失败返回-1 return -1; } saUdpServ.sin_family = AF_INET; saUdpServ.sin_addr.s_addr = htonl ( INADDR_BROADCAST ); saUdpServ.sin_port = htons (7001);//发送用的端口，可以根据需要更改 nSize = sizeof ( SOCKADDR_IN ); while(1) { sprintf(sendBuff,"Message %d",ncount++); sendto ( sockListener,sendBuff, lstrlen (sendBuff), 0, (SOCKADDR *) &saUdpServ, sizeof ( SOCKADDR_IN )); printf("%s ",sendBuff); }return 0;}///////////////////////接收#include <stdio.h>#include <winsock.h>#include <conio.h>int main(int argc, char* argv[]){ WSADATA wsaData; //指向WinSocket信息结构的指针 SOCKET sockListener; SOCKADDR_IN sin,saClient; char cRecvBuff[1024]; int nSize,nbSize; int iAddrLen=sizeof(saClient); if(WSAStartup(MAKEWORD( 1, 1 ), &wsaData )!=0)//进行WinSocket的初始化 { printf("Can"t initiates windows socket!Program stop. ");//初始化失败返回-1 return -1; } sockListener=socket(AF_INET, SOCK_DGRAM,0); sin.sin_family = AF_INET; sin.sin_port = htons(7001);//发送端使用的发送端口，可以根据需要更改 sin.sin_addr.s_addr = htonl(INADDR_ANY); if(bind( sockListener, (SOCKADDR FAR *)&sin, sizeof(sin))!=0) { printf("Can"t bind socket to local port!Program stop. ");//初始化失败返回-1 return -1; } while(1) { nSize = sizeof ( SOCKADDR_IN ); if((nbSize=recvfrom (sockListener,cRecvBuff,1024,0,(SOCKADDR FAR *) &saClient,&nSize))==SOCKET_ERROR) { printf("Recive Error"); break; } cRecvBuff[nbSize] = ""; printf("%s ",cRecvBuff);} return 0;}

1、要实现网络编程，首先得了解网络编程的原理。大部分网络编程底层都是通过TCP/IP或者UDP协议进行通讯，不管是TCP还是UDP通讯，都是通过调用socket实现的。Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。Socket通讯分为两部分：服务器端和客户端，服务器端监听客户端的连接，连接上之后，实现数据通讯，流程2、用C语言调用Socket实现通讯服务器端示例代码如下:#include#include#include#include#include#include#include#include#definePORT1500//端口号#defineBACKLOG5/*最大监听数*/intmain(){intsockfd,new_fd;/*socket句柄和建立连接后的句柄*/structsockaddr_inmy_addr;/*本方地址信息结构体，下面有具体的属性赋值*/structsockaddr_intheir_addr;/*对方地址信息*/intsin_size;sockfd=socket(AF_INET,SOCK_STREAM,0);//建立socketif(sockfd==-1){printf("socketfailed:%d

？？？？这个实在是？？？？封装？？？TCP/IP中要TCP包到IP包到以太帧的顺序封装数据包，你要传输的数据可能在不同的包中，每个包都有不同的数据头。

使用 vc 吧。是不是纯很重要吗？？？？？？

SOCKET在原理上应该是一样的，只是不同系统的运行机置有些不同。Socket 编程 windows到Linux代码移植遇到的问题1、一些常用函数的移植 2、网络socket相关程序从windows移植到linux下需要注意的 1)头文件 windows下winsock.h/winsock2.hlinux下sys/socket.h错误处理：errno.h 其他常用函数的头文件可到命令行下用man指令查询。2)初始化windows下需要用WSAStartuplinux下不需要（很方便），直接可以使用3)关闭socketwindows下closesocket(...)linux下close(...)4)类型windows下SOCKET在linux下为int类型5)绑定地址的结构体名称相同，都是struct sockaddr、struct sockaddr_in，这两者通常转换使用；

有问题请找锐英源啊。结合工作经验、开源、英语、视频教学、在线教学、阶段式兴趣和实践。面授小班授课，加强记忆，从头到尾结合实践。网校是视频教学和在线交流结合的。视频通俗易懂逐渐深入，在线灵活生动结合具体代码，可以结合例子，远程协助进行指导。

　　下面大概分几个方面进行罗列：　　Linux要包含　　[cpp]　　#include<sys/socket.h>　　#include<netinet/in.h>　　#include<netdb.h>　　#include<arpa/inet.h>　　等头文件，而windows下则是包含　　[cpp]　　#include<winsock.h>　　。　　Linux中socket为整形，Windows中为一个SOCKET。　　Linux中关闭socket为close，Windows中为closesocket。　　Linux中有变量socklen_t，Windows中直接为int。　　因为linux中的socket与普通的fd一样，所以可以在TCP的socket中，发送与接收数据时，直接使用read和write。而windows只能使用recv和send。　　设置socet选项，比如设置socket为非阻塞的。Linux下为　　[cpp]　　flag=fcntl(fd,F_GETFL);　　fcntl(fd,F_SETFL,flag|O_NONBLOCK);　　，Windows下为　　[cpp]　　flag=1;　　ioctlsocket(fd,FIONBIO,(unsignedlong*)&flag);　　。　　当非阻塞socket的TCP连接正在进行时，Linux的错误号为EINPROGRESS，Windows的错误号为WSAEWOULDBLOCK。

随着互联网编程技术的不断发展，现在大多数的软件开发都是通过编程语言来实现的，今天我们就一起来了解一下C语言编程开发技术都有哪些优势和劣势。C语言的一些好的体验一次通过阅读POV-Ray源代码学会如何在C语言中实现面向对象编程。通过阅读GTK+源代码了解C语言代码的清晰、干净和可维护性。通过阅读SIOD和Guile的源代码，知道如何使用C语言实现Scheme解析器。使用C语言写出GNOMEEye的初始版本，并对MicroTile渲染进行调优。C语言的一些不好的体验在Evolution团队时，很多东西老是崩溃。那个时候还没有Valgrind，为了得到Purify这个软件，需要购买一台Solaris机器。调试gnome-vfs线程死锁问题。调试Mesa，却无果。接手Nautilus-share的初始版本，却发现代码里面居然没有使用free()。想要重构代码，却不知道该如何管理好内存。想要打包代码，却发现到处是全局变量，而且没有静态函数。但不管怎样，还是来说说那些Rust里有但C语言里没有的东西吧。自动资源管理Rust从C++那里借鉴了一些想法，如RAII(ResourceAcquisitionIsInitialization，资源获取即初始化)和智能指针，并加入了值的单一所有权原则，还提供了自动化的决策性资源管理机制。自动化：不需要手动调用free()。内存使用完后会自动释放，文件使用完后会自动关闭，互斥锁在作用域之外会自动释放。如果要封装外部资源，基本上只要实现Drop这个trait就可以了。封装过的资源就像是编程语言的一部分，因为你不需要去管理它的生命周期。决策性：资源被创建(内存分配、初始化、打开文件等)，然后在作用域之外被销毁。根本不存在垃圾收集这回事：代码执行完就都结束了。程序数据的生命周期看起来就像是函数调用树。如果在写代码时老是忘记调用这些方法(free/close/destroy)，或者发现以前写的代码已经忘记调用，甚至错误地调用，那么以后我再也不想使用这些方法了。泛型Vec真的就是元素T的vector，而不只是对象指针的数组。在经过编译之后，它只能用来存放类型T的对象。在C语言里需要些很多代码才能实现类似的功能，所以我不想再这么干了。trait不只是interfaceRust并不是一门类似那样的面向对象编程语言，它有trait，看起来就像是里的interface——可以用来实现动态绑定。如果一个对象实现了Drawable，那么就可以肯定该对象带有draw()方法。不过不管怎样，trait的威力可不止这些。依赖管理以前实现依赖管理需要：手动调用或通过自动化工具宏来调用g-config。指定头文件和库文件路径。基本上需要人为确保安装了正确版本的库文件。而在Rust里，只需要编写一个Cargo.toml文件，然后在文件里指明依赖库的版本。这些依赖库会被自动下载下来，或者从某个指定的地方获取。测试C语言的单元测试非常困难，原因如下：内部函数通常都是静态的。也就是说，它们无法被外部文件调用。测试程序需要使用#include指令把源文件包含进来，或者使用#ifdefs在测试过程中移除这些静态函数。需要编写Makefile文件将测试程序链接到其中的部分依赖库或部分代码。需要使用测试框架，并把测试用例注册到框架上，还要学会如何使用这些框架。卫生宏(HygienicMacro)Rust的卫生宏避免了C语言宏可能存在的问题，比如宏中的一些东西会掩盖掉代码里的标识符。Rust并不要求宏中所有的符号都必须使用括号，比如max(5+3,4)。没有自动转型在C语言里，南邵北大青鸟发现很多bug都是因为在无意中将int转成short或char而导致，而在Rust里就不会出现这种情况，因为它要求显示转型。不会出现整型溢出这个就不用再多作解释了。

随着互联网编程技术的不断发展，现在大多数的软件开发都是通过编程语言来实现的，今天我们就一起来了解一下C语言编程开发技术都有哪些优势和劣势。C语言的一些好的体验一次通过阅读POV-Ray源代码学会如何在C语言中实现面向对象编程。通过阅读GTK+源代码了解C语言代码的清晰、干净和可维护性。通过阅读SIOD和Guile的源代码，知道如何使用C语言实现Scheme解析器。使用C语言写出GNOMEEye的初始版本，并对MicroTile渲染进行调优。C语言的一些不好的体验在Evolution团队时，很多东西老是崩溃。那个时候还没有Valgrind，为了得到Purify这个软件，需要购买一台Solaris机器。调试gnome-vfs线程死锁问题。调试Mesa，却无果。接手Nautilus-share的初始版本，却发现代码里面居然没有使用free()。想要重构代码，却不知道该如何管理好内存。想要打包代码，却发现到处是全局变量，而且没有静态函数。但不管怎样，还是来说说那些Rust里有但C语言里没有的东西吧。自动资源管理Rust从C++那里借鉴了一些想法，如RAII(ResourceAcquisitionIsInitialization，资源获取即初始化)和智能指针，并加入了值的单一所有权原则，还提供了自动化的决策性资源管理机制。自动化：不需要手动调用free()。内存使用完后会自动释放，文件使用完后会自动关闭，互斥锁在作用域之外会自动释放。如果要封装外部资源，基本上只要实现Drop这个trait就可以了。封装过的资源就像是编程语言的一部分，因为你不需要去管理它的生命周期。决策性：资源被创建(内存分配、初始化、打开文件等)，然后在作用域之外被销毁。根本不存在垃圾收集这回事：代码执行完就都结束了。程序数据的生命周期看起来就像是函数调用树。如果在写代码时老是忘记调用这些方法(free/close/destroy)，或者发现以前写的代码已经忘记调用，甚至错误地调用，那么以后我再也不想使用这些方法了。泛型Vec真的就是元素T的vector，而不只是对象指针的数组。在经过编译之后，它只能用来存放类型T的对象。在C语言里需要些很多代码才能实现类似的功能，所以我不想再这么干了。trait不只是interfaceRust并不是一门类似那样的面向对象编程语言，它有trait，看起来就像是里的interface——可以用来实现动态绑定。如果一个对象实现了Drawable，那么就可以肯定该对象带有draw()方法。不过不管怎样，trait的威力可不止这些。依赖管理以前实现依赖管理需要：手动调用或通过自动化工具宏来调用g-config。指定头文件和库文件路径。基本上需要人为确保安装了正确版本的库文件。而在Rust里，只需要编写一个Cargo.toml文件，然后在文件里指明依赖库的版本。这些依赖库会被自动下载下来，或者从某个指定的地方获取。测试C语言的单元测试非常困难，原因如下：内部函数通常都是静态的。也就是说，它们无法被外部文件调用。测试程序需要使用#include指令把源文件包含进来，或者使用#ifdefs在测试过程中移除这些静态函数。需要编写Makefile文件将测试程序链接到其中的部分依赖库或部分代码。需要使用测试框架，并把测试用例注册到框架上，还要学会如何使用这些框架。卫生宏(HygienicMacro)Rust的卫生宏避免了C语言宏可能存在的问题，比如宏中的一些东西会掩盖掉代码里的标识符。Rust并不要求宏中所有的符号都必须使用括号，比如max(5+3,4)。没有自动转型在C语言里，北京北大青鸟发现很多bug都是因为在无意中将int转成short或char而导致，而在Rust里就不会出现这种情况，因为它要求显示转型。不会出现整型溢出这个就不用再多作解释了。

linux下的网络通信程序，一定要和一个结构打交道，这个结构就是socketaddress。比如bind、connect等等函数都要使用socketaddress结构。理解socketaddress时我们要明白，其实在linux下针对于不同的socketdomain定义了一个通用的地址结构structsockaddr,它的具体定义为：{unsignedshortintsa_family;charsa_data[14];}structsockaddr其中，sa_family为调用socket()函数时的参数domain参数，sa_data为14个字符长度存储。针对于不同domain下的socket，通用地址结构又对应了不同的定义，例如一般的AF_INETdomain下，socketaddress的定义如下：structsockaddr_in{unsignedshortintsin_family;uint16_tsin_port;structin_addrsin_addr;unsignedcharsin_zero[8];//未使用}structin_addr{uint32_ts_addr;}当socket的domain不同于AF_INET时，具体的地址定义又是不同的，但是整个地址结构的大小、容量都是和通用地址结构一致的。

随着互联网编程技术的不断发展，现在大多数的软件开发都是通过编程语言来实现的，今天我们就一起来了解一下C语言编程开发技术都有哪些优势和劣势。C语言的一些好的体验一次通过阅读POV-Ray源代码学会如何在C语言中实现面向对象编程。通过阅读GTK+源代码了解C语言代码的清晰、干净和可维护性。通过阅读SIOD和Guile的源代码，知道如何使用C语言实现Scheme解析器。使用C语言写出GNOMEEye的初始版本，并对MicroTile渲染进行调优。C语言的一些不好的体验在Evolution团队时，很多东西老是崩溃。那个时候还没有Valgrind，为了得到Purify这个软件，需要购买一台Solaris机器。调试gnome-vfs线程死锁问题。调试Mesa，却无果。接手Nautilus-share的初始版本，却发现代码里面居然没有使用free()。想要重构代码，却不知道该如何管理好内存。想要打包代码，却发现到处是全局变量，而且没有静态函数。但不管怎样，还是来说说那些Rust里有但C语言里没有的东西吧。自动资源管理Rust从C++那里借鉴了一些想法，如RAII(ResourceAcquisitionIsInitialization，资源获取即初始化)和智能指针，并加入了值的单一所有权原则，还提供了自动化的决策性资源管理机制。自动化：不需要手动调用free()。内存使用完后会自动释放，文件使用完后会自动关闭，互斥锁在作用域之外会自动释放。如果要封装外部资源，基本上只要实现Drop这个trait就可以了。封装过的资源就像是编程语言的一部分，因为你不需要去管理它的生命周期。决策性：资源被创建(内存分配、初始化、打开文件等)，然后在作用域之外被销毁。根本不存在垃圾收集这回事：代码执行完就都结束了。程序数据的生命周期看起来就像是函数调用树。如果在写代码时老是忘记调用这些方法(free/close/destroy)，或者发现以前写的代码已经忘记调用，甚至错误地调用，那么以后我再也不想使用这些方法了。泛型Vec真的就是元素T的vector，而不只是对象指针的数组。在经过编译之后，它只能用来存放类型T的对象。在C语言里需要些很多代码才能实现类似的功能，所以我不想再这么干了。trait不只是interfaceRust并不是一门类似那样的面向对象编程语言，它有trait，看起来就像是里的interface——可以用来实现动态绑定。如果一个对象实现了Drawable，那么就可以肯定该对象带有draw()方法。不过不管怎样，trait的威力可不止这些。依赖管理以前实现依赖管理需要：手动调用或通过自动化工具宏来调用g-config。指定头文件和库文件路径。基本上需要人为确保安装了正确版本的库文件。而在Rust里，只需要编写一个Cargo.toml文件，然后在文件里指明依赖库的版本。这些依赖库会被自动下载下来，或者从某个指定的地方获取。测试C语言的单元测试非常困难，原因如下：内部函数通常都是静态的。也就是说，它们无法被外部文件调用。测试程序需要使用#include指令把源文件包含进来，或者使用#ifdefs在测试过程中移除这些静态函数。需要编写Makefile文件将测试程序链接到其中的部分依赖库或部分代码。需要使用测试框架，并把测试用例注册到框架上，还要学会如何使用这些框架。卫生宏(HygienicMacro)Rust的卫生宏避免了C语言宏可能存在的问题，比如宏中的一些东西会掩盖掉代码里的标识符。Rust并不要求宏中所有的符号都必须使用括号，比如max(5+3,4)。没有自动转型在C语言里，北京北大青鸟发现很多bug都是因为在无意中将int转成short或char而导致，而在Rust里就不会出现这种情况，因为它要求显示转型。不会出现整型溢出这个就不用再多作解释了。

简单的说就是通信的两方的一种约定，用套接字中的相关函数来完成通信过程应用层通过传输层进行数据通信时，TCP和UDP会遇到同时为多个应用程序进程提供并发服务的问题。多个TCP连接或多个应用程序进程可能需要通过同一个 TCP协议端口传输数据。为了区别不同的应用程序进程和连接，许多计算机操作系统为应用程序与TCP／IP协议交互提供了称为套接字(Socket)的接口。 区分不同应用程序进程间的网络通信和连接，主要有3个参数：通信的目的IP地址、使用的传输层协议(TCP或UDP)和使用的端口号。Socket原意是 “插座”。通过将这3个参数结合起来，与一个“插座”Socket绑定，应用层就可以和传输层通过套接字接口，区分来自不同应用程序进程或网络连接的通信，实现数据传输的并发服务。 -- win API socket 本文所谈到的Socket函数如果没有特别说明，都是指的Windows Socket API。 一、WSAStartup函数 int WSAStartup( WORD wVersionRequested, LPWSADATA lpWSAData ); 使用Socket的程序在使用Socket之前必须调用WSAStartup函数。该函数的第一个参数指明程序请求使用的Socket版本，其中高位字节指明副版本、低位字节指明主版本；操作系统利用第二个参数返回请求的Socket的版本信息。当一个应用程序调用WSAStartup函数时，操作系统根据请求的Socket版本来搜索相应的Socket库，然后绑定找到的Socket库到该应用程序中。以后应用程序就可以调用所请求的 Socket库中的其它Socket函数了。该函数执行成功后返回0。 例：假如一个程序要使用2.1版本的Socket,那么程序代码如下 wVersionRequested = MAKEWORD( 2, 1 ); err = WSAStartup( wVersionRequested, &wsaData ); 二、WSACleanup函数 int WSACleanup (void); 应用程序在完成对请求的Socket库的使用后，要调用WSACleanup函数来解除与Socket库的绑定并且释放Socket库所占用的系统资源。 三、socket函数 SOCKET socket( int af, int type, int protocol ); 应用程序调用socket函数来创建一个能够进行网络通信的套接字。第一个参数指定应用程序使用的通信协议的协议族，对于TCP/IP协议族，该参数置PF_INET;第二个参数指定要创建的套接字类型，流套接字类型为SOCK_STREAM、数据报套接字类型为SOCK_DGRAM；第三个参数指定应用程序所使用的通信协议。该函数如果调用成功就返回新创建的套接字的描述符，如果失败就返回INVALID_SOCKET。套接字描述符是一个整数类型的值。每个进程的进程空间里都有一个套接字描述符表，该表中存放着套接字描述符和套接字数据结构的对应关系。该表中有一个字段存放新创建的套接字的描述符，另一个字段存放套接字数据结构的地址，因此根据套接字描述符就可以找到其对应的套接字数据结构。每个进程在自己的进程空间里都有一个套接字描述符表但是套接字数据结构都是在操作系统的内核缓冲里。下面是一个创建流套接字的例子： struct protoent *ppe; ppe=getprotobyname("tcp"); SOCKET ListenSocket=socket(PF_INET,SOCK_STREAM,ppe->p_proto); 四、closesocket函数 int closesocket( SOCKET s ); closesocket函数用来关闭一个描述符为s套接字。由于每个进程中都有一个套接字描述符表，表中的每个套接字描述符都对应了一个位于操作系统缓冲区中的套接字数据结构，因此有可能有几个套接字描述符指向同一个套接字数据结构。套接字数据结构中专门有一个字段存放该结构的被引用次数，即有多少个套接字描述符指向该结构。当调用closesocket函数时，操作系统先检查套接字数据结构中的该字段的值，如果为1，就表明只有一个套接字描述符指向它，因此操作系统就先把s在套接字描述符表中对应的那条表项清除，并且释放s对应的套接字数据结构；如果该字段大于1，那么操作系统仅仅清除s在套接字描述符表中的对应表项，并且把s对应的套接字数据结构的引用次数减1。 closesocket函数如果执行成功就返回0，否则返回SOCKET_ERROR。 五、send函数 int send( SOCKET s, const char FAR *buf, int len, int flags ); 不论是客户还是服务器应用程序都用send函数来向TCP连接的另一端发送数据。客户程序一般用send函数向服务器发送请求，而服务器则通常用 send函数来向客户程序发送应答。该函数的第一个参数指定发送端套接字描述符；第二个参数指明一个存放应用程序要发送数据的缓冲区；第三个参数指明实际要发送的数据的字节数；第四个参数一般置0。这里只描述同步Socket的send函数的执行流程。当调用该函数时，send先比较待发送数据的长度 len和套接字s的发送缓冲区的长度，如果len大于s的发送缓冲区的长度，该函数返回SOCKET_ERROR；如果len小于或者等于s的发送缓冲区的长度，那么send先检查协议是否正在发送s的发送缓冲中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送s的发送缓冲中的数据或者s的发送缓冲中没有数据，那么send就比较s的发送缓冲区的剩余空间和len，如果len大于剩余空间大小send就一直等待协议把s的发送缓冲中的数据发送完，如果len小于剩余空间大小send就仅仅把buf中的数据copy到剩余空间里（注意并不是send把s的发送缓冲中的数据传到连接的另一端的，而是协议传的，send仅仅是把buf中的数据copy到s的发送缓冲区的剩余空间里）。如果send函数copy数据成功，就返回实际copy的字节数，如果send在copy数据时出现错误，那么send就返回SOCKET_ERROR；如果send在等待协议传送数据时网络断开的话，那么send 函数也返回SOCKET_ERROR。要注意send函数把buf中的数据成功copy到s的发送缓冲的剩余空间里后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个Socket函数就会返回SOCKET_ERROR。（每一个除 send外的Socket函数在执行的最开始总要先等待套接字的发送缓冲中的数据被协议传送完毕才能继续，如果在等待时出现网络错误，那么该Socket 函数就返回SOCKET_ERROR） 注意：在Unix系统下，如果send在等待协议传送数据时网络断开的话，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。 六、recv函数 int recv( SOCKET s, char FAR *buf, int len, int flags ); 不论是客户还是服务器应用程序都用recv函数从TCP连接的另一端接收数据。该函数的第一个参数指定接收端套接字描述符；第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据；第三个参数指明buf的长度；第四个参数一般置0。这里只描述同步Socket的recv函数的执行流程。当应用程序调用recv函数时，recv先等待s的发送缓冲中的数据被协议传送完毕，如果协议在传送s的发送缓冲中的数据时出现网络错误，那么 recv函数返回SOCKET_ERROR，如果s的发送缓冲中没有数据或者数据被协议成功发送完毕后，recv先检查套接字s的接收缓冲区，如果s接收缓冲区中没有数据或者协议正在接收数据，那么recv就一直等待，只到协议把数据接收完毕。当协议把数据接收完毕，recv函数就把s的接收缓冲中的数据 copy到buf中（注意协议接收到的数据可能大于buf的长度，所以在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据copy完。 recv函数仅仅是copy数据，真正的接收数据是协议来完成的），recv函数返回其实际copy的字节数。如果recv在copy时出错，那么它返回 SOCKET_ERROR；如果recv函数在等待协议接收数据时网络中断了，那么它返回0。 注意：在Unix系统下，如果recv函数在等待协议接收数据时网络断开了，那么调用recv的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。 七、bind函数 int bind( SOCKET s, const struct sockaddr FAR *name, int namelen ); 当创建了一个Socket以后，套接字数据结构中有一个默认的IP地址和默认的端口号。一个服务程序必须调用bind函数来给其绑定一个IP地址和一个特定的端口号。客户程序一般不必调用bind函数来为其Socket绑定IP地址和断口号。该函数的第一个参数指定待绑定的Socket描述符；第二个参数指定一个sockaddr结构，该结构是这样定义的： struct sockaddr { u_short sa_family; char sa_data[14]; }; sa_family指定地址族，对于TCP/IP协议族的套接字，给其置AF_INET。当对TCP/IP协议族的套接字进行绑定时，我们通常使用另一个地址结构： struct sockaddr_in { short sin_family; u_short sin_port; struct in_addr sin_addr; char sin_zero[8]; }; 其中sin_family置AF_INET；sin_port指明端口号；sin_addr结构体中只有一个唯一的字段s_addr，表示IP地址，该字段是一个整数，一般用函数inet_addr（）把字符串形式的IP地址转换成unsigned long型的整数值后再置给s_addr。有的服务器是多宿主机，至少有两个网卡，那么运行在这样的服务器上的服务程序在为其Socket绑定IP地址时可以把htonl(INADDR_ANY)置给s_addr，这样做的好处是不论哪个网段上的客户程序都能与该服务程序通信；如果只给运行在多宿主机上的服务程序的Socket绑定一个固定的IP地址，那么就只有与该IP地址处于同一个网段上的客户程序才能与该服务程序通信。我们用0来填充 sin_zero数组，目的是让sockaddr_in结构的大小与sockaddr结构的大小一致。下面是一个bind函数调用的例子： struct sockaddr_in saddr； saddr.sin_family = AF_INET; saddr.sin_port = htons(8888); saddr.sin_addr.s_addr = htonl(INADDR_ANY); bind(ListenSocket,(struct sockaddr *)&saddr,sizeof(saddr))； 八、listen函数 int listen( SOCKET s, int backlog ); 服务程序可以调用listen函数使其流套接字s处于监听状态。处于监听状态的流套接字s将维护一个客户连接请求队列，该队列最多容纳backlog个客户连接请求。假如该函数执行成功，则返回0；如果执行失败，则返回SOCKET_ERROR。 九、accept函数 SOCKET accept( SOCKET s, struct sockaddr FAR *addr, int FAR *addrlen ); 服务程序调用accept函数从处于监听状态的流套接字s的客户连接请求队列中取出排在最前的一个客户请求，并且创建一个新的套接字来与客户套接字创建连接通道，如果连接成功，就返回新创建的套接字的描述符，以后与客户套接字交换数据的是新创建的套接字；如果失败就返回 INVALID_SOCKET。该函数的第一个参数指定处于监听状态的流套接字；操作系统利用第二个参数来返回新创建的套接字的地址结构；操作系统利用第三个参数来返回新创建的套接字的地址结构的长度。下面是一个调用accept的例子： struct sockaddr_in ServerSocketAddr; int addrlen; addrlen=sizeof(ServerSocketAddr); ServerSocket=accept(ListenSocket,(struct sockaddr *)&ServerSocketAddr,&addrlen); 十、connect函数 int connect( SOCKET s, const struct sockaddr FAR *name, int namelen ); 客户程序调用connect函数来使客户Socket s与监听于name所指定的计算机的特定端口上的服务Socket进行连接。如果连接成功，connect返回0；如果失败则返回SOCKET_ERROR。下面是一个例子： struct sockaddr_in daddr; memset((void *)&daddr,0,sizeof(daddr)); daddr.sin_family=AF_INET; daddr.sin_port=htons(8888); daddr.sin_addr.s_addr=inet_addr("133.197.22.4"); connect(ClientSocket,(struct sockaddr *)&daddr,sizeof(daddr))；