C++博客-f(sixleaves) = sixleaves-随笔分类-program language

Ruby-EX1鲁比入门

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

摘要: Ruby入门阅读全文

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

C++面向对象总结（一）

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

1.创建对象：

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

2.C++中了this指针：

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

内部机制：

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

1.this指针是const类型，不可改变。

2.this指针针对对象，所以静态成员是没有this指针的。

3.构造函数和析构函数

构造函数就不说了，只说下默认构造函数就死className() {},默认会生成。但是如果你自己定义了构造函数，而且不是定义成默认构造函数，就要在定义一下默认构造函数，不然创建对象时候必须指定参数，不能用无参数的。

析构函数，就是用来在对象要销毁时候，回收一些对象自己向系统申请的内存。析构函数调用完后，系统才清除对象本身占据的内存。

Tips：

1.析构函数不能重载，只有一种形式~className() {},这是和构造函数的区别

2.三种情况下调用析构函数，对象离开局部作用域后，撤销对象触发，程序终止，触发；delete运算符回收new创建的对象触发；临时匿名函数使用完毕；

4.拷贝构造函数和单参构造函数

（1）拷贝构造函数，其实就是构造函数中的单参数形式的构造函数，只是其参数比较特别，是对自身同类对象的引用。拷贝构造函数在一下几个的方会用到。

Date a;Date b(a);//调用的就是拷贝构造函数

Date b = a；//调用的也是拷贝构造函数

function(Date d)｛….｝；function(a);//调用的也是拷贝构造函数（先创建Date类的匿名对象，然后调用拷贝构造函数）

Date c = function(a);//这边function返回Date对象，也是调用拷贝构造函数（没有创建匿名对象）

（2）单参构造函数

单参数构造函数。其实拷贝构造函数也是单参构造函数。但是我将他们区别开来，主要是单参构造函数，主要是用在，隐式的类型转换上。

如你定义了一个Integer类，直接Integer a = 1；是会出错的。因为1不能自动或者隐含的转换成Integer对象，所以这时候你就要定义

单参数构造函数，用来让自动转换，在java中称为包装。由于是构造函数，参数中的类型就是那个要转换的类型。其它和基本构造函数一样。

5.静态成员

静态成员又分为静态数据成员和静态函数成员。C++中的静态函数成员和java也没区别。主要是静态数据成员。所以我们总结下静态数据成员

（1）静态数据成员和类共存亡而不是和对象。

（2）静态数据成员在类加载时候分配空间并进行初始化，而不是在对象加载时候。所以静态数据成员默认初始化为0。

重点是：类中的静态数据成员知识一份声明，必须在类外重新定义并初始化静态数据成员。

（3）类外通过类作用域运算符：：访问静态数据成员。

6.const用法

（1）const成员函数，这时候const加载函数名后面｛｝之前。表示函数不会改变当前对象的状态，而且只能调用const成员函数。（养成习惯，能加尽量加）

Tips：这里const也是函数签名的一部分。

（2）const对象，表示常量对象。

（3）const形参，表示函数中不会改变该形参。注意：常量对象，只能调用const成员函数，因为这才能保证状态不被改变，同时这样保证了他就是常量对象。

Tips：这里const也是函数签名的一部分。

（4）const返回值，说明返回值是不可以改变的。

以上这些都是总结，不是写给没基础的人看的。只是为了方便整理和记忆。

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

运算符重载-友原函数(结构体、类和运算符重载)

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

最近在练习算法、觉得有必要总结下C++这方面的知识，C++确实是复杂，but i love it。
第一：运算符重载的基本应用。第二：运算符重载于友原函数的关系。第三：结构体于类关于运算符重载的区别。首先我需要普及下基本的知识：
预备知识：operator(操作符)、operand(操作数)、表达式
表达式是由操作符和操作数构成的，而且一般每个表达式都有副作用，并且都有结果（关注结果和副作用）。什么意思？
关于副作用的理解：其实就是在达到结果的这个过程中所做的一些事情，而这些事情产生了一些影响，但是不影响结果。
好像有点绕、看看例子在理解吧。
看例子：
int a = 1,b=2,c; c = a + b;
在这段代码里面，c = a + b;就是表达式、其中 = 、 + 又称为操作符、c、a、b又称为操作数。其结果就是计算出了a+b的值，副作用没有。
又比如：
cout << "Helloe" << endl;其中 <<是操作符、cout、"helloe"、endl是操作数。<<的结果是返回了ostream的引用，而副作用就是将"Helloe"输出到屏幕。

第一：运算符重载的基本应用。
看如下代码：

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{//这种是最基本的方式、其本质是做操作数调用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 }

如上代码：
注释掉的先不用看，12--17行就是最基本的运算符重载、其调用在38行，本质是：c = a.operator+(b);也就是调用做操作数的方法那么还要友元函数干什么呢？考虑下输出，如果你想让cout对象能自动输出Point的对象如何半到。你很聪明一定想到重载<<运算符、yes！right！于是把operator<<作为成员函数，你只能写成上面注释掉的哪样，那么调用时，麻烦就来了、编程39行的样子。尼玛丫、真实变态、我是想让它是cout << c << endl。搞得四不像了。是的就是因为这样子不好用，所以我们要结合友元函数的技术和运算重载技术来实现40行的调用。好了重点来了！谨记之！
tips:对于非成员函数的运算符重载，第一个参数就是左操作数，第二个操作数就是右操作数。
第二：运算符重载和友原函数的关系
所以上面的友元函数的参数顺序是cout对象的引用是第一个参数、Point对象引用为第二个参数。
我们还要解决第二个问题，如何让这个函数访问Point对象的私有部分，只要在Point类中声明，hello我是你的朋友啦、他的东西就是你的啦、你要怎么用怎么用，这才是朋友么！不、是基友！我认为应该叫做基友函数，哈哈。声明格式就是加上friend和函数的声明即可。
tips:成员函数和非成员函数的运算符重载的区别就是，参数个数不一样。成员函数中的左操作数不用体现出来（用this即可）、而非成员函数的左右操作数都要体现在运算符函数参数里面。
第三：结构体和类关于运算符重载的区别
关于区别，其实只有一个，因为结构体默认的权限是public、即其成员对外界都是可见的，所以其不需要友元函数来支持，但是其还是需要用非成员函数来重载<<比较方便、而不是用成员函数来重载<<.原因上面已经说过了。注意这个原因不是友元这项技术体现出来的，而是成员函数和非成员函数体现出来的，友元技术知识用来支撑其在类中的应用。、
tips:对于结构体，非成员函数的运算符重载方法，不需要声明为友元函数。
如下代码：

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{//这种是最基本的方式、其本质是做操作数调用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

函数指针是一个重难点，看完书本后，决定写篇自己做下总结。
首先在C++\C中，函数的函数名本身就是地址，而函数指针就是存储这个地址的变量。
如下代码void fun(int a, int b) {.....}；函数，其fun就是一个指针，也就是存的是地址，
而void (*p)(int, int) = fun；就是指向这个函数的指针，其实说来p函数指针这时也使指
向这个函数的，所以要使用这个函数的话，理论上应该写成(*p)(2, 3);这种形式，但是实
际上，通过p(2, 3)也可以成功调用，所以我们可以把函数指针在某种情况下当成函数的别
名，虽然这样不符合逻辑，当然，如果你比较较真，可以使用(*p)(2, 3);这边讲了这么多
现在来总结下如何声明一个特定类型的函数指针吧。
知识点1:
声明特定类型的函数指针:
1.先写出要声明的指定函数的原型prototype。如void fun(int , int );
2.把prototype中的函数名替换成(*p)，如void (*p)(int , int );
经过上面两步，你就声明了一个指向无返回值，带有两个int类型的函数的函数指针p。
哇，原来函数指针这么简单啊、谁说指针很复杂的，谁说指针很难的，拉出去斩了、欺骗我们幼小的心灵。
此时你可能会问，怎么调用啊，怎么调用啊，首先你要给他赋值，其次，调用分两种，就是上面一开始说
的那两种。说白了，也就是对于函数指针调用函数，你可以解引用，可以刻直接用地址。

知识点2:
声明特定类型的函数指针数组:
1.和知识点一1,2步一样,我们先写出一个。第二步在想办法写成一个数组
2.把(*p)替换成(*p[3])这样p就是一个包含3个函数指针的数组。也就是说p是函数指针的指针！
什么意思！什么叫做指针的指针，你在说什么！，哈哈有得人看到这开始晕了，那么后面的你更晕，其实说白了p是指向数组的第一个元素
也就是说p的地址值是第一个元素的地址，所以说p是函数指针的指针啊，因为p指向的时函数指针，函数指针指向的才是内存中函数指令区域的那个块!

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

知识点4:
问题:
假设有const double * (*pa[3])(const double * , int ) = {f1, f2, f3}，声明指向该函数指针数组的指针。

有了知识点3，理解知识点4就十分容易了。
1.C11方法auto pc = &pa; C11的方式十分简单方便但是对于不支持C11的请看第二个，最原始的方法
2.分析:因为我们要声明的时一个指针，而不是一个数组所以首先用(*pd)把其扩起来，然后其是指向一个函数指针数组，这个数组有3个元素。所以其核心部分就是(*pd)[3],此时的意思就是所pd是一个指针，其指向包含3个元素的数组
所以第三步我们要说明，数组元素的类型了，类型就是const double * (*)(const double *, int),也就是const double * (* (*pd)[3])(const double *, int)。
tips:
有人反映第三步类型看不懂，其实很简单，我举个例子，
1.int *p;p的类型是int *,
2.而int *p[3],p的类型是int * [3]也很好理解就是带有三个数组，元素类型都是int *。
3.而int (*p[3])(int )，p的类型是int (*[3])(int),p是指向一个3个元素的数组，且每个元素的类型都是int (*)(int)。
(指针是什么类型主要看括号、*号、[]号,和参数列表的结合顺序，如果只有(*p)(int ,....)那p就是函数指针)
所以有以下推论。
元素的数据类型推论：
要判断数组或指针的类型，就是拿掉<数组名、指针名>后组成的，而且[]和*是从右向左结合。
要判断数组元素的类型，就是在数组类型的基础上把大小拿掉。

知识点5:
使用typedef创建函数指针类型别名:
1.typedef简化函数指针其本质就是为函数指针的类型取别名。
如下：
typedef const double *(*p_fun)(const double *, int);其是此时相当于typedef Const double *(*)(const double *, int) p_fun;
当然你不能这样写，这样写只是方便你理解。
p_fun不是函数指针了，而是这种函数指针类型的别名，所以此时你可以这样做
p_fun p1 = f1;
p_fun pa[3] = {f1, f2, f3};
p_fun (*pd)[3] = &pa;
是不是比之前的简单许多！，这个很重要哦
好了函数指针就总结到这，如有不足请指教。
以下是测试代码：测试代码参考自C++ Primer Plus

1 //
2 //
3 //  Unit7
4 //
5 //  Created by sixleaves on 14-7-26.
6 //  Copyright (c) 2014年 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;//严密的逻辑性调用
31     cout << p2(av, 3) << ": " << *p2(av, 3) << endl;//感性调用
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章 <<循环和计数>>

swp — Fri, 21 Feb 2014 08:21:00 GMT

回顾第1章，第一章我们认识到了变量的定义，定义ing时赋值，操作符重载（Overloaded），和没有深入探讨的构造函数，成员函数的概念、符号直接量（与字符直接量的区别），还有输入输出缓冲模型之其好处（三个事件才会刷新缓冲区，输出到设备上，分别是，缓冲区已经满，遇到cin，显示要求刷新（如std::endl，控制符（manipulator）））。
这章我写得有点急切，应为之前C++学过，有些概念一跳而过，看不懂的，可以往下找红色字体处开始（从循环不变式分析处开始的分析，再回头来看这个）。

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 }

#
#分析：我们现在需要重写（重构//we have...后面的代码），应该这样思考，以前的那个程序不具备好的可扩展性，为什么呢？首先如果要求输入的框架编程10行（空白#行变成10行），后面的代码久要多加很多行，一行行的进行输出。这时我们可以用循环对代码进行重构。我们先分析，在greeting上下空白行只有一行，所以我们用pad
#表示空白行，而总的行数为2 * pad + 3（头尾加greeting那行）。这样我们就可以让程序输出任意多行。于是有如下代码

const int pad = 1;

const int rows = pad * 2 + 3;

#另外我们这个输出的框架是要让左右两边的空白数和上下两端的空白数相同，所以也只需要定义一个变量就够了。每一行输出的字符数就是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 }

#第一个：：说明string名字定义在名字空间std中，而第二个：：则表示size_type来自string类。std::string定义了size_type，用来表示一个string中含有的字#符数目。如果需要一个局部变量来表示一个string长度，可以使用std::string::size_type类型定义一个变量。
#size_type是一个无符号的类型
#输出边界字符，如果r = 0，由循环不变式可以知道，现在一行也没有输出。所以当r = row - 1，已经输出了row - 1行，接下来输出的是最后一个部分，类似的，如果c = 0，输出的将是第一列的部分。
#输出边界符号：
#那么我们如何判断输出greeting这行呢，由循环不变式，我们可以 r = pad + 1 时，c = pad + 1时，开始输出greeting。

#第二章写得有点乱，上面代码看不懂的，请看下面分析
#首先我们要介绍一个概念，叫做循环不变式，循环不变式就是我们设置一个断言，让该断言在该循环中始终都成立，结束后也成立，这样这个断言其实就是这段程序的意思。看如
#下代码：

//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

#首先你应该想一想要确保不变式始终为true，只要确保在循环进入点为true，一次循环结束点为true，那么这个不变式久永远为true，understand？如果还不理解，先吧我说
#的这句话理解了，在继续往下看，不然你不知道我在讲什么东西!
#我们的不变式就是上述断言invariant:we have written r rows so far
#我们分析过，不变式的两个断点，一个设在开头，一个在结尾，所以开头时r = 0。此时程序一行也没输出，不变式为true，在结尾处r++后，仍为true，为什么呢？举个例子，r = 0，进来之后，将输出一行，所以此时r不应该在为0，而应该为1.
#这是每一行输出的框架，转换成for循环就是上面相应的代码，而至于另外一个循环一样个道理。
#下面再介绍一个重要的概念，这个概念我之前还真没学好，看完后，恍然大悟，大测大悟阿！那就是循环时的计数问题。
#在C中C++中我们写循环经常是重int i = 0，从0开始是不？就算是，你是不是经常这样写for(int i = 0; i <= number; i++);但是更好的写法应该是for(int i = 0; i #!= number; i++);为什么呢？请听我慢慢道来.
#首先我们知道在不对称区间[0, rows)计数的话，很明显就是rows个数，但是如果你使用的是对称区间，[num,rows]则有rows - num + 1个数，是不是很不明显，再则从0开 #始一目了然，别说你看不出来，我在举个例子（0，66],和[21,86]哪一个你能快速判断出有几个数。
#有的人又说，这算什么阿，我从1开始贝[1,66]，不就多算一个数么，习惯就好。我想说，你说的没粗，但我懒，用不对称区间跟块算出，更不会出错。在则，用不对称区间的好 #处是容易和invariant（循环不变式）相结合，例如，如果你从1开始计数，有的人想我们把不变式改成现在输出第r行，但是这样是不能作为一个不变式的，所谓不变式，就是
#这个断言永远正确，但是当你结束循环时r = rows + 1，就变成了输出第rows + 1行，但这个不变式就变成错的鸟，understand。
#再则我们选者！=而不是<=来作为比较操作符。这个差别很小，但是很不一样，前者，循环结束时（只要没有在循环里break），就能判断此时r = rows，但是如果是后者，我 #们这能证明至少输出了rows行，为啥？回忆下学过的math，<=,是什么意思？
#还有一条好处，我就不罗嗦了，综上所属，你可以发现从0开始计数的好处！，想当一时，在写链表时，就是因为这个计数问题，自己也整了个证明方法，哈哈，每想到早就有更 #简单的方式了。
#本人才疏学浅，看不懂的，可以留言讨论之。

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

sixleaves之AC++杂谈录第1章 <<使用字符串>>

swp — Thu, 20 Feb 2014 12:38:00 GMT

回顾:在第0章中我总结了重要的知识点有：字符串直接量、表达式的结构，操作数和操作符的定义，还有表达式的副作用、和std::cout结合<<操作符返回std::ostream类型，等知识点。
代码如下

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就是一个变量（它的类型是std::string），而变量是一个有名字的对象（变量一定是对象，但对象不一定为变量，因为对象可以没有名字，而且对象对应系统中的一块内存）。
#line 11：是一个definition，即是一个定义，定义了一个名叫做name的std::string类型的变量。而且出现在一个函数提中，所以是一个local variable，当程序执行放到}，就会销毁name变量，并且释放name占用的内存，以让其他变量使用。
#line 12：>>从标准输入中读取一个字符串，并且保存它在name对象中。当通过标准库读取一个字符串时，他会忽略输入中的所有空白符，而吧其他字符读取到name中，直到它遇到其他空白符或者文件结束标志。因此std::cin >> name;的结果是从标准输入中读取一个单词。
#输入输出库会把它的输出保存在buffer的内部数据结构上，通过缓存可以优化输出操作。（因为许多操作系统在向输出设备写入字符时需要花大量的时间）
#有三个事件会促使系统刷新缓冲区。
#第一，缓存区满了，自动刷新。
#第二，标准库被要求读取标准输入流。（即std::cin是std::istream类型）。如line 12.
#第三，显示的要求刷新缓冲。（std::endl结束了输出行，并且刷新缓冲区)
# 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的定义包含三个新的概念

#第一个：在定义变量时候，可以给定它的值。

#第二个：用+来连接字符串，但是这两个中必须至少有一个是string对象。（+也是左结合性的）

#（+在这里是连接作用),引出overloaded（重载）概念，这个操作符被重载了，因为其对不同操作数有不同的含义。

#第三个：const可以作为变量定义的一部分，这么做保证在变量生存期内，不改变它的值。

#如果一个变量定义为const，必须在定义时初始化，否则后面就不能再初始化。

#const std::string spaces(greeting.size(), ' ');来介绍另三个概念

#第一个：构造函数

#第二个：成员函数(member function),其实可以吧greeting看成对象，向其发送size消息获取其长度。

#第三个：字符直接量。（用'（单引号），而字符串直接量则是用“号）.字符直接量的类型是内置于语言核心的char类型。

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

sixleaves之AC++杂谈录第0章

swp — Wed, 19 Feb 2014 14:10:00 GMT

@import url(http://www.cppblog.com/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css); 前言：
选择自己心中最新欢的事情去做，毕竟之前计算机基础课程基础也打得不错，深入的学习C++。我一直相信母亲说过的一句话：“不要认为你做不到，只要你想去做，就一定能做得到”。自我勉励之。同时开博是为了总结自己学习，希望能对有些人有所帮助。

由very simple的小程序包含的许多C++基础知识。

1 //a small C++ program
2 #include
3
4 int main()
5 {
6 std::cout << "Hello, world!" << std::endl;
7 return 0;
8 }

#程序的第一行为注释，//是行注释。
#std是一个命名空间（名字空间）namespace
#对于return语句，return 0表示程序正常退出。
#对于return语句，如果是函数的定义要求返回某种特殊类型的值，那么这个函数中所有的return语句都必须返回相应类型的值。
#剖析“Hello world！程序的总结”如下
#该程序中有两个贯穿C++的概念，表达式和生存空间（scope）
#表达式
#表达式的作用是请求系统进行计算。计算后会生成一个结果，同时也可能会有一些副作用。（所谓的副作用就是它会影响程序或者系统的状态）。行6也是个表达式
，它的副作用是在标准输出流输出“Hello， world！”并且当行结束。
#表达式由操作符和操作数（operand）构成。如行6，两个<<符号都是操作符，而剩下的std::cout、“Hello world”、std::endl则是操作数。
#操作数：每个操作数都是一种类型。（即都表示一种数据结构和它适合的操作，它决定了操作符的脾气（产生的结果），总而言之只要记住操作数决定了操作符的脾气。）（int表示整数类型，std::ostream定义为流输出，std::cout的类型是std::ostream）
#操作符：<<操作符有左结合性（left-assocoative）左结合性是一种贪心思想，当表达式出现两个以上的<<，左结合性总是贪心左边的操作数。
#分析：第一个<<是以std::cout作为它的左操作数，而以"Hello， world"作为右操作数。
第二个<<的左操作数是一个（生成std::cout结果）的表达式，其类型是std::ostream.右操作数是std::endl,是一个mainpulator（控制符）。当<<
左操作符是std::ostream,而右操作数是mainpulator时，<<会根mainpulator的语义来控制流输出，并且返回流作为它的结果。如：当mainpulator是
std::endl时，它结束当前输出行。
#scope
#namespace:命名空间机制，相当于java中的包机制。
#scope,中文称为生存空间，：：是生存空间操作符，::左边是生存空间的表示符std，而右边就是定义在命名空间中的名字。
#“Hello，world”称为字符串直接量，字符串直接量中，一些字符前面加上(\)后具有特殊的意义。

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