国产尤物精品,国产精品视频导航,亚洲欧洲精品一区二区三区不卡

Ruby-EX1鲁比入门

swp — Fri, 01 May 2015 17:16:00 GMT

摘要: Ruby入门阅读全文

swp 2015-05-02 01:16 发表评论

swp — Thu, 04 Sep 2014 09:18:00 GMT

1.创徏对象�Q?/font>

在java中创建对象只能用new才行�Q�返回的是引用类型，所以对象名其实是引用。而C++中的对象创徏不一��P��C++可以用指针存对象�Q�相当于引用。也可以直接用类标识�W�来创徏对象。如Person是类�Q�Person a,b�Q�在C++中就创徏了两个对象，在java中是Person对象的引用�?/font>

2.C++中了this指针�Q?/font>

C++中的this指针和java中的一栗��在C++中，this指针指向当前对象�Q�this指针隐含在每个成员函��C��中，其类型是class className *.

内部机制�Q?/font>

在C++中访问数据成员都是隐含的使用this指针操作的。需要注意的是�?/font>

1.this指针是const�c�d��Q�不可改变�?/font>

2.this指针针对对象�Q�所以静态成员是没有this指针的�?/font>

3.构造函数和析构函数

构造函数就不说了，只说下默认构造函数就死className() {},默认会生成。但是如果你自己定义了构造函敎ͼ�而且不是定义成默认构造函敎ͼ��p��在定义一下默认构造函敎ͼ�不然创徏对象时候必��L��定参敎ͼ�不能用无参数的�?/font>

析构函数�Q�就是用来在对象要销毁时候，回收一些对象自己向�pȝ��甌��的内存。析构函数调用完后，�pȝ��才清除对象本�w�占据的内存�?/font>

Tips�Q?/font>

1.析构函数不能重蝲�Q�只有一�U��Ş式~className() {},�q�是和构造函数的区别

2.三种情况下调用析构函敎ͼ�对象��d��局部作用域后，撤销对象触发�Q�程序终止，触发�Q�delete�q�算�W�回收new创徏的对象触发；临时匿名函数使用完毕�Q?/font>

4.拯��构造函数和单参构造函�?/font>

�Q?�Q�拷贝构造函敎ͼ�其实��是构造函��C��的单参数形式的构造函敎ͼ�只是其参数比较特别，是对自��n同类对象的引用。拷贝构造函数在一下几个的方会用到�?/font>

Date a;Date b(a);//调用的就是拷贝构造函�?/font>

Date b = a�Q?/调用的也是拷贝构造函�?/font>

function(Date d)�?#8230;.｝；function(a);//调用的也是拷贝构造函敎ͼ�先创建Date�cȝ��匿名对象�Q�然后调用拷贝构造函敎ͼ�

Date c = function(a);//�q�边function�q�回Date对象�Q�也是调用拷贝构造函敎ͼ�没有创徏匿名对象�Q?/font>

�Q?�Q�单参构造函�?/font>

单参数构造函数。其实拷贝构造函��C��是单参构造函数。但是我��他们区别开来，主要是单参构造函敎ͼ�主要是用在，隐式的类型�{换上�?/font>

如你定义了一个Integer�c�，直接Integer a = 1�Q�是会出错的。因�?不能自动或者隐含的转换成Integer对象�Q�所以这时候你��p��定义

单参数构造函敎ͼ�用来让自动�{换，在java中称为包装。由于是构造函敎ͼ�参数中的�c�d��是那个要�{换的�c�d��。其它和基本构造函��C��栗��?/font>

5.静态成�?/font>

静态成员又分�ؓ静态数据成员和静态函数成员。C++中的静态函数成员和java也没区别。主要是静态数据成员。所以我们�ȝ��下静态数据成�?/font>

�Q?�Q�静态数据成员和�c�d��存亡而不是和对象�?/font>

�Q?�Q�静态数据成员在�c�d��载时候分配空间�ƈ�q�行初始化，而不是在对象加蝲时候。所以静态数据成员默认初始化�?�?/font>

重点是：�c�M��的静态数据成员知识一份声明，必须在类外重新定义�ƈ初始化静态数据成员�?/font>

�Q?�Q�类外通过�c�M��用域�q�算�W�：�Q�访问静态数据成员�?/font>

6.const用法

�Q?�Q�const成员函数�Q�这时候const加蝲函数名后�?｛｝之前。表�C�函��C��会改变当前对象的状态，而且只能调用const成员函数。（��L��习惯�Q�能加尽量加�Q?/font>

Tips�Q�这里const也是函数�{�֐�的一部分�?/font>

�Q?�Q�const对象�Q�表�C�常量对象�?/font>

�Q?�Q�const形参�Q�表�C�函��C��不会改变该�Ş参。注意：帔R��对象�Q�只能调用const成员函数�Q�因��才能保证状态不被改变，同时�q�样保证了他��是帔R��对象�?/font>

Tips�Q�这里const也是函数�{�֐�的一部分�?/font>

�Q?�Q�const�q�回��|��说明�q�回值是不可以改变的�?/font>

以上�q�些都是�ȝ��Q�不是写�l�没基础的�h看的。只是�ؓ了方便整理和记忆�?/font>

swp 2014-09-04 17:18 发表评论

�q�算�W�重�?友原函数(�l�构体、类和运��符重蝲)

swp — Fri, 29 Aug 2014 08:31:00 GMT

最�q�在�l�习��法、觉得有必要�ȝ��下C++�q�方面的知识�Q�C++��实是复杂，but i love it�?/span>
�W�一�Q�运��符重蝲的基本应用。第二：�q�算�W�重载于友原函数的关�p�R��第三：�l�构体于�c�d��于运��符重蝲的区别。首先我需要普及下基本的知识：
预备知识�Q?/span>operator(操作�W?、operand(操作�?、表辑ּ�
表达式是由操作符和操作数构成的，而且一般每个表辑ּ�都有副作用，�q�且都有�l�果�Q�关注结果和副作用）。什么意思？
关于副作用的理解�Q�其实就是在辑ֈ��l�果的这个过�E�中所做的一些事情，而这些事情��生了一些媄响，但是不媄响结果�?/span>
好像有点�l�、看看例子在理解吧�?/span>
看例子：
int a = 1,b=2,c; c = a + b;
在这�D�代码里面，c = a + b;��是表达式、其�?= �?+ 又称为操作符、c、a、b又称为操作数。其�l�果��是计算��Z��a+b的��|��副作用没有�?/span>
又比如：
cout << "Helloe" << endl;其中 <<是操作符、cout�?helloe"、endl是操作数�?lt;<的结果是�q�回了ostream的引用，而副作用��是��?Helloe"输出到屏�q��?/span>

�W�一�Q�运��符重蝲的基本应用�?/strong>
看如下代码：

1 #include
2
3 using namespace std;
4
5 class Point {
6 private:
7     double x,y;
8 public:
9     Point(double x = 0, double y = 0):x(x),y(y) {
10
11     }
12     Point operator+(const Point &p) const{//�q�种是最基本的方式、其本质是做操作数调用operator+函数
13         Point temp;
14         temp.x = this->x + p.x;
15         temp.y = this->y + p.y;
16         return temp;
17     }
18     /*
19     ostream& operator<<(ostream& out) {
20         out << x << " " << y;
21         return out;
22     }
23     */
24     friend ostream& operator<<(ostream& out, Point & p);
25 };
26 ///*
27 ostream& operator<<(ostream& out, Point & p) {
28     out << p.x <<" "<< p.y;
29     return out;
30 }
31 //*/
32
33 int main() {
34
35     Point a(1,5);
36     Point b(5,7);
37     Point c;
38     c = a + b;
39     //c << cout << endl;
40     cout << c << endl;
41     return 0;
42 }
如上代码�Q?/span>
注释掉的先不用看�Q?2--17行就是最基本的运��符重蝲、其调用�?8行，本质是：c = a.operator+(b);也就是调用做操作数的�Ҏ��那么�q�要友元函数�q�什么呢�Q�考虑下输出，如果你想让cout对象能自动输出Point的对象如何半到。你很聪明一定想到重�?lt;<�q�算�W�、yes�Q�right�Q�于是把operator<<作�ؓ成员函数�Q�你只能写成上面注释掉的哪样�Q�那么调用时�Q�麻烦就来了、编�E?9行的样子。尼玛丫、真实变态、我是想让它是cout << c << endl。搞得四不像了。是的就是因��样子不好用，所以我们要�l�合友元函数的技术和�q�算重蝲技术来实现40行的调用。好了重�Ҏ��了！谨记之！
tips:对于非成员函数的�q�算�W�重载，�W�一个参数就是左操作敎ͼ��W�二个操作数��是��x��作数�?/span>
�W�二�Q?/span>�q�算�W�重载和友原函数的关�p?/span>
所以上面的友元函数的参数顺序是cout对象的引用是�W�一个参数、Point对象引用为第二个参数�?/span>
我们�q�要解决�W�二个问题，如何让这个函数访问Point对象的私有部分，只要在Point�c�M��声明�Q�hello我是你的朋友啦、他的东西就是你的啦、你要怎么用怎么用，�q�才是朋友么�Q�不、是基友�Q�我认�ؓ应该叫做基友函数�Q�哈哈。声明格式就是加上friend和函数的声明卛_��?/span>
tips:成员函数和非成员函数的运��符重蝲的区别就是，参数个数不一栗��成员函��C��的左操作��C��用体现出来（用this卛_��Q�、而非成员函数的左��x��作数都要体现在运��符函数参数里面�?/span>
�W�三�Q?/strong>�l�构体和�c�d��于运��符重蝲的区�?/strong>
关于区别�Q�其实只有一个，因�ؓ�l�构体默认的权限是public、即其成员对外界都是可见的，所以其不需要友元函数来支持�Q�但是其�q�是需要用非成员函数来重蝲<<比较方便、而不是用成员函数来重�?lt;<.原因上面已经说过了。注意这个原因不是友元这��Ҏ��术体现出来的�Q�而是成员函数和非成员函数体现出来的，友元技术知识用来支撑其在类中的应用。�?br />tips:对于�l�构体，非成员函数的�q�算�W�重载方法，不需要声明�ؓ友元函数�?/span>
如下代码�Q?/span>
1 #include
2
3 using namespace std;
4
5 struct Point{
6     double x,y;
7     Point(double x = 0, double y = 0):x(x),y(y) {
8
9     }
10     Point operator+(const Point &p) const{//�q�种是最基本的方式、其本质是做操作数调用operator+函数
11         Point temp;
12         temp.x = this->x + p.x;
13         temp.y = this->y + p.y;
14         return temp;
15     }
16 };
17
18 ostream& operator<<(ostream& out, Point & p) {
19     out << p.x <<" "<< p.y;
20     return out;
21 }
22
23
24 int main() {
25
26     Point a(1,5);
27     Point b(5,7);
28     Point c;
29     c = a + b;
30     cout << c << endl;
31     return 0;
32 }

swp 2014-08-29 16:31 发表评论

深入探讨函数指针

swp — Sat, 26 Jul 2014 10:08:00 GMT
函数指针是一个重隄��Q�看完书本后�Q�决定写��自己做下�ȝ��?/span>
首先在C++\C中，函数的函数名本��n��是地址�Q�而函数指针就是存储这个地址的变量�?/span>
如下代码void fun(int a, int b) {.....}�Q�函敎ͼ�其fun��是一个指针，也就是存的是地址�Q?/span>
而void (*p)(int, int) = fun�Q�就是指向这个函数的指针�Q�其实说来p函数指针�q�时也��?/span>
向这个函数的�Q�所以要使用�q�个函数的话�Q�理��Z��应该写成(*p)(2, 3);�q�种形式�Q�但是实
际上�Q�通过p(2, 3)也可以成功调用，所以我们可以把函数指针在某�U�情况下当成函数的别
名，虽然�q�样不符合逻辑�Q�当�Ӟ��如果你比较较真，可以使用(*p)(2, 3);�q�边讲了�q�么�?/span>
现在来�ȝ��下如何声明一个特定类型的函数指针吧�?/span>
知识�?:
声明特定�c�d��的函数指�?
1.先写��声明的指定函数的原型prototype。如void fun(int , int );
2.把prototype中的函数名替换成(*p)�Q�如void (*p)(int , int );
�l�过上面两步�Q�你��声明了一个指向无�q�回��|��带有两个int�c�d��的函数的函数指针p�?/span>
哇，原来函数指针�q�么��单啊、谁说指针很复杂的，谁说指针很难的，拉出��L��了、欺骗我们幼��的心灵�?/span>
此时你可能会问，怎么调用啊，怎么调用啊，首先你要�l�他赋��|��其次�Q�调用分两种�Q�就是上面一开始说
的那两种。说白了�Q�也��是对于函数指针调用函数�Q�你可以解引用，可以�ȝ��接用地址�?/span>

知识�?:
声明特定�c�d��的函数指针数�l?
1.和知识点一1,2步一�?我们先写��Z��个。第二步在想办法写成一个数�l?br /> 2.�?*p)替换�?*p[3])�q�样p��是一个包�?个函数指针的数组。也��是说p是函数指针的指针�Q?/span>
什么意思！什么叫做指针的指针�Q�你在说什么！�Q�哈哈有得�h看到�q�开始晕了，那么后面的你更晕�Q�其实说白了p是指向数�l�的�W�一个元�?br />也就是说p的地址值是�W�一个元素的地址�Q�所以说p是函数指针的指针啊，因�ؓp指向的时函数指针�Q�函数指针指向的才是内存中函数指令区域的那个�?

知识�?:
对于数组p[n]区别�Q�p�?amp;p的重大区�?
前言�Q�我们知道p指向数组的第一个元素，所以p�{��h�?amp;p[0]�Q�所以我们可以轻易看出区别了�Q�p�?amp;p
的相同点是在数字上，他们相同�Q�但是在大小上，或者说�c�d��上，他们不同�Q?amp;p指向的时整个�?br /> �l�，如果&p + 1则跨��的时整个数�l�。其实我们可以从指针定义的运��来理解�Q�我们知道，指针
的加加，本质上是地址的跨��，而跨��的长度�Q�取决于地址的类型，&p是指向数�l�的指针�Q�所�?br /> 其跨��的长度�Q�肯定是一整个数组�Q�而p指向的时数组中得�W�一个元素，所以p + 1�Q�跨��的时数
�l�的一个元素�?/span>
1.p�?amp;p的相同点�Q�在于数��g��Q�他们都是那个内存块的地址�Q�而那个内存块用一个地址标志�Q�所以他们的数字相同�?br />2.p�?amp;p的区别在于类型上�Q�p是指向一个元素的�Q?amp;p是指向一个数�l�的�Q�所以p + 1�?amp;p + 1有十分大得区别�?/span>

知识�?:
问题:
假设�?/span>const double * (*pa[3])(const double * , int ) = {f1, f2, f3}�Q?/span>声明指向该函数指针数�l�的指针�?br />
有了知识�?�Q�理解知识点4��十分容易了�?/span>
1.C11�Ҏ��auto pc = &pa; C11的方式十分简单方便但是对于不支持C11的请看第二个�Q�最原始的方�?br /> 2.分析:因�ؓ我们要声明的时一个指针，而不是一个数�l�所以首先用(*pd)把其扩�v来，然后其是指向一个函数指针数�l�，�q�个数组�?个元素。所以其核心部分��是(*pd)[3],此时的意思就是所pd是一个指针，其指向包�?个元素的数组
所以第三步我们要说明，数组元素的类型了�Q�类型就是const double * (*)(const double *, int),也就�?/span>const double * (* (*pd)[3])(const double *, int)�?br />tips:
有�h反映�W�三步类型看不懂�Q�其实很��单，我�D个例子，
1.int *p;p的类型是int *,
2.而int *p[3],p的类型是int * [3]也很好理解就是带有三个数�l�，元素�c�d��都是int *�?br />3.而int (*p[3])(int )�Q�p的类型是int (*[3])(int),p是指向一�?个元素的数组�Q�且每个元素的类型都是int (*)(int)�?br />(指针是什么类型主要看括号�?受��[]�?和参数列表的�l�合��序�Q�如果只�?*p)(int ,....)那p��是函数指针)
所以有以下推论�?/span>
元素的数据类型推论：
要判断数�l�或指针的类型，��是拿掉<数组名、指针名>后组成的�Q�而且[]�?是从叛_��左结合�?br />要判断数�l�元素的�c�d��Q�就是在数组�c�d��的基��上把大小拿掉�?br />
知识�?:
使用typedef创徏函数指针�c�d��别名:
1.typedef��化函数指针其本质��是为函数指针的�c�d��取别名�?/span>
如下�Q?br /> typedef const double *(*p_fun)(const double *, int);其是此时相当于typedef Const double *(*)(const double *, int) p_fun;
当然你不能这样写�Q�这样写只是方便你理解�?br /> p_fun不是函数指针了，而是�q�种函数指针�c�d��的别名，所以此时你可以�q�样�?br /> p_fun p1 = f1;
p_fun pa[3] = {f1, f2, f3};
p_fun (*pd)[3] = &pa;
是不是比之前的简单许多！�Q�这个很重要�?br />好了函数指针��ȝ��到这�Q�如有不��指教�?br />以下是测试代码：��试代码参考自C++ Primer Plus
1 //
2 //
3 //  Unit7
4 //
5 //  Created by sixleaves on 14-7-26.
6 //  Copyright (c) 2014�q?nbsp;sixleaves. All rights reserved.
7 //
8
9 #include
10
11 const double * f1(const double ar[], int n);
12 const double * f2(const double [], int);
13 const double * f3(const double *, int);
14
15 int main() {
16
17     using namespace std;
18     double av[3] = {1112.3, 1542.6, 2227.9};
19
20
21     //pointer to a function
22     const double * (*p1)(const double *, int) = f1;
23     auto p2 = f2;//C++11 automatic type deduction
24     //pre-C11 can use the following code instead
25     //const double * (*p2)(const double *, int) = f2;
26
27
28     cout << "Using pointers to functions:\n";
29     cout << "Address Value\n";
30     cout << (*p1)(av, 3) << ": " << *(*p1)(av, 3) << endl;//严密的逻辑性调�?/span>
31     cout << p2(av, 3) << ": " << *p2(av, 3) << endl;//感性调�?br />32
33     //pa an array of pointers
34     //auto doesn't work with list initialization
35     const double *(*pa[3])(const double *, int) = {f1, f2, f3};
36     //but it does work for initializing to a single value
37     //pb a pointer to  fitst element of pa
38     auto pb = pa;
39     //pre-c11 can use the following code instead
40     //const double *(**pb)(const double *, int) = pa;
41
42     cout << "\nUsing an array of pointer to functions:\n";
43     cout << " Address Value\n";
44     for (int i = 0; i < 3; i++) {
45         cout << pb[i](av, 3) << ": " << *pb[i](av, 3) <46     }
47
48     //what about a pointer to an array of function pointers;
49     cout << "\nUsing pointers to an array of function pointers:\n";
50     cout << " Adress Values\n";
51     //easy way to declare pc
52     auto pc = &pa;
53     //pre c11 can use the following code instead
54     //const double *(*(*pc)[3])(const double *, int) = &pa;
55
56     cout << (*pc)[0](av, 3) << ": " << *(*pc)[0](av, 3) << endl;
57
58     //hard way to declare pd;
59     const double *(*(*pd)[3])(const double *, int) = &pa;
60
61     //store return value in pdb;
62     const double *pdb = (*pd)[1](av, 3);
63     cout << pdb << ": " << *pdb << endl;
64
65     //alternative notation
66     cout << (*(*pd)[2])(av, 3) << ": " << *(*(*pd)[2])(av, 3) << endl;
67
68     return 0;
69 }
70 const double * f1(const double ar[], int n) {
71     return ar;
72 }
73 const double * f2(const double ar[], int) {
74     return ar + 1;
75 }
76 const double * f3(const double ar[], int) {
77     return ar + 2;
78 }
79

swp 2014-07-26 18:08 发表评论

sixleaves之AC++杂谈录第2�?<<循环和计�?gt;>

swp — Fri, 21 Feb 2014 08:21:00 GMT
回顾�W?章，�W�一章我们认识到了变量的定义�Q�定义ing时赋��|��操作�W�重载（Overloaded�Q�，和没有深入探讨的构造函敎ͼ�成员函数的概��c��符��L��接量�Q�与字符直接量的区别�Q�，�q�有输入输出�~�冲模型之其好处�Q�三个事件才会刷新缓冲区�Q�输出到讑֤�上，分别是，�~�冲区已�l�满�Q�遇到cin�Q�显�C��求刷斎ͼ�如std::endl�Q�控制符�Q�manipulator�Q�）�Q��?br />�q�章我写得有�Ҏ��切�Q�应��Z��前C++学过�Q�有些概念一跌��过�Q�看不懂的，可以往下找�U�色字体处开始（从��@环不变式分析处开始的分析�Q�再回头来看�q�个�Q��?br />
1 #include
2 #include <string>
3
4 int main() {
5     //ask for the person's name
6     std::cout << "Please enter your first name: ";
7
8     //read the name
9     std::string name;
10     std::cin >> name;
11
12     //build the message that we intend to write
13     const std:;string greeting = "Hello, " + name + "!";
14
15     //we have to rewrite this part
16 }
#
#分析�Q�我们现在需要重写（重构//we have...后面的代码）�Q�应该这��h��考，以前的那个程序不具备好的可扩展性，��Z��么呢�Q�首先如果要求输入的框架�~�程10行（�I�白#行变�?0行）�Q�后面的代码久要多加很多行，一行行的进行输出。这时我们可以用循环对代码进行重构。我们先分析�Q�在greeting上下�I�白行只有一行，所以我们用pad
#表示�I�白行，而�ȝ��行数�? * pad + 3�Q�头��֊�greeting那行�Q�。这��h��们就可以让程序输��Z�Q意多行。于是有如下代码

const int pad = 1;

const int rows = pad * 2 + 3;
#另外我们�q�个输出的框架是要让左右两边的空白数和上下两端的�I�白数相同，所以也只需要定义一个变量就够了。每一行输出的字符数就是greeting的长度加上pad * 2加上两个#两个星号。即如下代码const std::string::size_type cols = greeting.size() + pad * 2 + 2;

1
2 #include
3 #include <string>
4 using std::cin;        using std::endl;
5 using std::cout;   using std::string;
6 int main() {
7     cout << "Please enter your first name: ";
8
9     string name;
10     cin >> name;
11
12     const string greeting = "Hello, " + name + "!";
13
14     const int pad = 1;
15
16     const int rows = pad * 2 + 3;
17     const string::size_type cols = greeting.size() + pad * 2 + 2;
18
19     cout << endl;
20
21     // invariant:we have written r rows so far
22     for(int r = 0; r != rows; ++r) {
23
24         string::size_type c = 0;
25
26         // invariant:we have written c characters so far in the current row
27         while(c != cols) {
28
29             if(r == pad + 1 && c == pad + 1) {
30                 cout << greeting;
31                 c += greeting.size();
32             } else {
33
34                 if(r == 0 || r == rows -1 || c == 0 || c == cols - 1)
35                     cout << "*";
36                 else
37                     cout << " ";
38                 ++c;
39             }
40         }
41
42         cout << endl;
43
44     }
45     return 0;
46 }
#�W�一个：�Q�说明string名字定义在名字空间std中，而第二个�Q�：则表�C�size_type来自string�c�R��std::string定义了size_type�Q�用来表�C�Z��个string中含有的�?�W�数目。如果需要一个局部变量来表示一个string长度�Q�可以��用std::string::size_type�c�d��定义一个变量�?br /> #size_type是一个无�W�号的类�?br /> #输出边界字符�Q�如果r = 0�Q�由循环不变式可以知道，现在一行也没有输出。所以当r = row - 1�Q�已�l�输��Z��row - 1行，接下来输出的是最后一个部分，�c�M��的，如果c = 0�Q�输出的��是�W�一列的部分�?br /> #输出边界�W�号�Q?br /> #那么我们如何判断输出greeting�q�行呢，由��@环不变式�Q�我们可�?r = pad + 1 �Ӟ��c = pad + 1�Ӟ��开始输出greeting�?br />
#�W�二章写得有点�ؕ�Q�上面代码看不懂的，��L��下面分析
#首先我们要介�l�一个概念，叫做循环不变式，循环不变式就是我们设�|�一个断�a��Q�让该断�a�在该循环中始�l�都成立�Q�结束后也成立，�q�样�q�个断言其实��是�q�段�E�序的意思。看�?br /> #下代码：

//invariant:we have written r rows so far

int r = 0;
//setting r to 0 makes the invariant true

while(r != rows) {
    //we can assume that the invariant is true here
    //waiting a row of output makes the invariant false
    std::cout << std::endl;
    //incrementing r makes the invariant true again
r++;
}
//we can conclude that the invariant is true here
#首先你应该想一惌��保不变式始�l��ؓtrue�Q�只要确保在循环�q�入点�ؓtrue�Q�一�ơ��@环结束点为true�Q�那么这个不变式久永�q��ؓtrue�Q�understand�Q�如果还不理解，先吧我说
#的这句话理解了，在��l�往下看�Q�不然你不知道我在讲什么东�?
#我们的不变式��是上述断言invariant:we have written r rows so far
#我们分析�q�，不变式的两个断点�Q�一个设在开��_��一个在�l�尾�Q�所以开头时r = 0。此时程序一行也没输出，不变式�ؓtrue�Q�在�l�尾处r++后，仍�ؓtrue�Q��ؓ什么呢�Q��D个例子，r = 0�Q�进来之后，��输��Z��行，所以此时r不应该在�?�Q�而应该�ؓ1.
#�q�是每一行输出的框架�Q��{换成for循环��是上面相应的代码，而至于另外一个��@环一样个道理�?br />#下面再介�l�一个重要的概念�Q�这个概忉|��之前�q�真没学好，看完后，恍然大悟�Q�大��大悟阿�Q�那��是循环时的计数问题�?br /> #在C中C++中我们写循环�l�常是重int i = 0�Q�从0开始是不？��q��是，你是不是�l�常�q�样写for(int i = 0; i <= number; i++);但是更好的写法应该是for(int i = 0; i #!= number; i++);��Z��么呢�Q�请听我慢慢道来.
#首先我们知道在不对称区间[0, rows)计数的话�Q�很明显��是rows个数�Q�但是如果你使用的是对称区间�Q�[num,rows]则有rows - num + 1个数�Q�是不是很不明显�Q�再则从0开 #始一目了�Ӟ��别说你看不出来，我在举个例子�Q?�Q?6],和[21,86]哪一个你能快速判断出有几个数�?br /> #有的人又��_��q�算什么阿�Q�我�?开始贝[1,66]�Q�不��多��一个数么，习惯��好。我惌��Q�你说的没粗�Q�但我懒�Q�用不对�U�区间跟块算出，更不会出错。在则，用不对称区间的好 #处是�Ҏ��和invariant�Q��@环不变式�Q�相�l�合�Q�例如，如果你从1开始计敎ͼ�有的人想我们把不变式�Ҏ��现在输出�W�r行，但是�q�样是不能作��Z��个不变式的，所谓不变式�Q�就�?br /> #�q�个断言永远正确�Q�但是当你结束��@环时r = rows + 1�Q�就变成了输出第rows + 1行，但这个不变式��变成错的鸟�Q�understand�?br /> #再则我们选者！=而不�?lt;=来作为比较操作符。这个差别很��，但是很不一��P��前者，循环�l�束�Ӟ��只要没有在��@环里break�Q�，��p��判断此时r = rows�Q�但是如果是后者，�? #们这能证明至��输��Z��rows行，为啥�Q�回忆下学过的math�Q?lt;=,是什么意思？
#�q�有一条好处，我就不罗嗦了�Q�综上所属，你可以发��C��0开始计数的好处�Q�，惛_��一�Ӟ��在写链表�Ӟ��是因�ؓ�q�个计数问题�Q�自�׃��整了个证明方法，哈哈�Q�每惛_��早就有更 #��单的方式了�?br />#本�h才疏学浅�Q�看不懂的，可以留言讨论之�?img src ="http://www.shnenglu.com/sixleaves/aggbug/205872.html" width = "1" height = "1" />

swp 2014-02-21 16:21 发表评论

sixleaves之AC++杂谈录第1�?<<使用字符�?gt;>

swp — Thu, 20 Feb 2014 12:38:00 GMT
回顾:在第0章中我�ȝ��了重要的知识�Ҏ��Q�字�W�串直接量、表辑ּ�的结构，操作数和操作�W�的定义�Q�还有表辑ּ�的副作用、和std::cout�l�合<<操作�W�返回std::ostream�c�d��Q�等知识炏V�?br /> 代码如下

1 // ask for person's name, and greet the person
2
3 #include
4 #include <string>
5
6 int main() {
7     //ask for the person's name
8     std::cout << "Please enter your first name: ";
9
10     //read the name
11     std::string name;
12     std::cin >> name;
13
14     //write a greeting
15     std::cout << "Hello, " << name << "!" << std::endl;
16     return 0;
17 }
#name��是一个变量（它的�c�d��是std::string�Q�，而变量是一个有名字的对象（变量一定是对象�Q�但对象不一定�ؓ变量�Q�因为对象可以没有名字，而且对象对应�pȝ��中的一块内存）�?br /> #line 11�Q�是一个definition�Q�即是一个定义，定义了一个名叫做name的std::string�c�d��的变量。而且出现在一个函数提中，所以是一个local variable�Q�当�E�序执行攑ֈ�}�Q�就会销毁name变量�Q��ƈ且释放name占用的内存，以让其他变量使用�?br /> #line 12�Q?gt;>从标准输入中��d��一个字�W�串�Q��ƈ且保存它在name对象中。当通过标准库读取一个字�W�串�Ӟ��他会忽略输入中的所有空白符�Q�而吧其他字符��d��到name中，直到它遇到其他空白符或者文件结束标志。因此std::cin >> name;的结果是从标准输入中��d��一个单词�?br /> #输入输出库会把它的输��Z��存在buffer的内部数据结构上�Q�通过�~�存可以优化输出操作。（因�ؓ许多操作�pȝ��在向输出讑֤�写入字符旉��要花大量的时��_��
#有三个事件会促�ɾpȝ��h��~�冲区�?br /> #�W�一�Q�缓存区满了�Q�自动刷新�?br /> #�W�二�Q�标准库被要求读取标准输入流。（即std::cin是std::istream�c�d��Q�。如line 12.
#�W�三�Q�显�C�的要求��h��~�冲。（std::endl�l�束了输��Q��ƈ且刷新缓冲区)
# 1 //ask for a person's name, and generate a framed greeting
2 #include
3 #include <string>
4
5 int main() {
6     std::cout << "Please enter your first name: ";
7     std::string name;
8     std::cin >> name;
9     //build the message that we intend to write
10     const std::string greeting = "Hello, " + name + "!";
11
12     //build the second and fourth lines of the input
13     const std::string spaces(greeting.size(), ' ');
14     const std::string second = "* " + spaces + " *";
15
16     //build the first and fifth lines of the output
17     const std::string first(second.size(), '*');
18
19     //write it all
20     std::cout << std::endl;
21     std::cout << first < 22     std::cout << second << std::endl;
23     std::cout << "* " << greeting << " *" << std::endl;
24     std::cout << second << std::endl;
25     std::cout << first << std::endl;
26
27     return 0;
28 }
#greeting的定义包含三个新的概�?/div>
#�W�一个：在定义变量时候，可以�l�定它的倹{�?/div>
#�W�二个：�?来连接字�W�串�Q�但是这两个中必��至��有一个是string对象。（+也是左结合性的�Q?/div>
#�Q?在这里是�q�接作用),引出overloaded�Q�重载）概念�Q�这个操作符被重载了�Q�因为其对不同操作数有不同的含义�?/div>
#�W�三个：const可以作�ؓ变量定义的一部分�Q�这么做保证在变量生存期内，不改变它的倹{�?/div>
#如果一个变量定义�ؓconst�Q�必��d��定义时初始化�Q�否则后面就不能再初始化�?/div>
#const std::string spaces(greeting.size(), ' ');来介�l�另三个概念
#�W�一个：构造函�?/div>
#�W�二个：成员函数(member function),其实可以吧greeting看成对象�Q�向其发送size消息获取光��度�?/div>
#�W�三个：字符直接量。（�?�Q�单引号�Q�，而字�W�串直接量则是用“��P��.字符直接量的�c�d��是内�|�于语言核心的char�c�d��?/div>

swp 2014-02-20 20:38 发表评论

swp — Wed, 19 Feb 2014 14:10:00 GMT
@import url(http://www.shnenglu.com/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css); 前言�Q?br /> 选择自己心中最新欢的事情去做，毕竟之前计算机基��评��基础也打得不错，深入的学习C++。我一直相信母亲说�q�的一句话�Q?#8220;不要认�ؓ你做不到�Q�只要你惛_��做，��׃��定能做得�?#8221;。自我勉�׃��。同时开博是��Z��ȝ��自己学习�Q�希望能�Ҏ��些�h有所帮助�?br />
由very simple的小�E�序包含的许多C++基础知识�?br />
1 //a small C++ program
2 #include
3
4 int main()
5 {
6      std::cout << "Hello, world!" << std::endl;
7      return 0;
8 }
#�E�序的第一行�ؓ注释�Q?/是行注释�?
#std是一个命名空��_��名字�I�间�Q�namespace
#对于return语句�Q�return 0表示�E�序正常退出�?nbsp;
#对于return语句�Q�如果是函数的定义要求返回某�U�特�D�类型的��|��那么�q�个函数中所有的return语句都必��返回相应类型的倹{�?br /> #剖析“Hello world�Q�程序的�ȝ��”如下
#该程序中有两个诏�I�C++的概念，表达式和生存�I�间�Q�scope�Q?br /> #表达�?br /> #表达式的作用是请求系�l�进行计��。计��后会生成一个结果，同时也可能会有一些副作用。（所谓的副作用就是它会媄响程序或者系�l�的状态）。行6也是个表辑ּ�
�Q�它的副作用是在标准输出��输�?#8220;Hello�Q?world�Q?#8221;�q�且当行�l�束�?br /> #表达式由操作�W�和操作敎ͼ�operand�Q�构成。如�?�Q�两�?lt;<�W�号都是操作�W�，而剩下的std::cout�?#8220;Hello world”、std::endl则是操作数�?br /> #操作敎ͼ�每个操作数都是一�U�类型。（即都表示一�U�数据结构和它适合的操作，它决定了操作�W�的脾气�Q��生的�l�果�Q�，总而言之只要记住操作数军_��了操作符�? 脾气。）�Q�int表示整数�c�d��Q�std::ostream定义为流输出�Q�std::cout的类型是std::ostream�Q?br /> #操作�W�：<<操作�W�有左结合性（left-assocoative�Q�左�l�合性是一�U�贪心思想�Q�当表达式出��C��个以上的<<�Q�左�l�合性��L��贪心左边的操作数�?br /> #分析�Q�第一�?lt;<是以std::cout作�ؓ它的左操作数�Q�而以"Hello�Q?world"作�ؓ��x��作数�?br /> �W�二�?lt;<的左操作数是一个（生成std::cout�l�果�Q�的表达式，其类型是std::ostream.��x��作数是std::endl,是一个mainpulator�Q�控制符�Q�。当<<
左操作符是std::ostream,而右操作数是mainpulator�Ӟ��<<会根mainpulator的语义来控制��输出，�q�且�q�回��作为它的结果。如�Q�当mainpulator�?br /> std::endl�Ӟ��它结束当前输��?br /> #scope
#namespace:命名�I�间机制�Q�相当于java中的包机制�?br /> #scope,中文�U�Cؓ生存�I�间�Q�：�Q�是生存�I�间操作�W�，::左边是生存空间的表示�W�std�Q�而右边就是定义在命名�I�间中的名字�?br /> #“Hello�Q�world”�U�Cؓ字符串直接量�Q�字�W�串直接量中�Q�一些字�W�前面加�?\)后具有特�D�的意义�?img src ="http://www.shnenglu.com/sixleaves/aggbug/205855.html" width = "1" height = "1" />

swp 2014-02-19 22:10 发表评论

国产尤物精品,国产精品视频导航,亚洲欧洲精品一区二区三区不卡

Ruby-EX1鲁比入门

�q�算�W�重�?友原函数(�l�构体、类和运���符重蝲)

深入探讨函数指针

sixleaves之AC++杂谈录第2�?<<循环和计�?gt;>

sixleaves之AC++杂谈录第1�?<<使用字符�?gt;>

�q�算�W�重�?友原函数(�l�构体、类和运��符重蝲)