GeekBand C++ Week1 Notes

GeekBand C++ Week1 Notes

A．OOP-面向对象编程

1基础：C语言

-变量variable

-类型types

-作用域scope

-循环loops

-流程控制

-程序的编译和连结（如何运行）

2目标编程习惯

C++class

Objectbased基于对象，单个类

-Classwithout pointer members (complex)

-classwith pointer members (string)

Objectoriented面向对象，类之间的关系

-inheritance继承

-composition复合？？

-delegation委托？？

多态？？封装？？

三个例子

Complex.h complex-test.cpp

String.h string-test.cpp

Oop-demo.h oop-test.cpp

C++历史

B语言69，C语言72，C++83

OO：java, C#

C++98（1.0），C++03（TR1），C++11（2.0），C++14

加的新特性讲的C++98??????

C++语言（主要谈）C++标准库（庞大有用）

书：C++ primer，C++ programming language

C++standard library STL源码剖析

B．头文件和类声明

C语言和C++的比较

C数据和函数的变量是全局的（没封装的坏处）

C++数据和函数（方法）包在一起->建立很多对象

类里面带指针和不带指针：

不带指针：复数类，数据有实部和虚部，方法有加减乘除等

带指针：字符串类，字符串是一个指针（另外分配空间存放字符串），方法有拷贝输出附加等。

C++里面创建对象的方式

C++代码基本形式：

.h headfiles

classes declaration

.cpp

#inlcude//<>从标准库里找

#include”complex.h”//””从自己写的里面找

ex.main()

延伸名称不一定是.h和.cpp，不同平台

C++ #include

Cout << “I = “ << I <

C#include

Printf(“”)

头文件的写法

Complex.h

#ifndef ___COMPLEX__

#define __COMPLEX__//guard,防卫式声明

//***********0,声明************//

#include

class ostream;

class comlex;

complex&

__doap1(complex* ths, const complex& r);

//*********1,类和声明********//

class complex{

}

//********2,类，定义*********//

complex::function …

#endif

第二次include时可以skip，防止重复代码DRY！

1和2最重要，0是为了声明

语法：复数类的声明，模板的应用

template

class complex{

public:

complex(T r = 0, T i = 0)

:re(r), im(i)

{}

complex&operator += (const complex&);

T real () const{return re;}

T imag () const{return im;}

Private:

Tre, im;

friendcomplex& __doap1(complex*, const complex&);

}

template是模板，可以改变类中的某些值？已定义的变量名，可以改变值？还是需要用方法改变。

调用时，

complex c1(2.5, 1.5);

complex c2(2, 6);

C. class的声明

Complex& operator,没有大括号的方法内容，只是一个声明。

Complex& operator += (constcomplex&);

Inline函数：如果函数在class内定义完成是inline函数（内联函数）

Double real () const {return re;}

Double imag () const {return im;}

Inline function会比较快比较好。但没有可能所有函数都是inline，函数太复杂无法inline???是不是Inline由编译器决定。。。上面两个函数在body内定义则为inline function但最后是不是真的是由编译器决定。

Inline double

Imag(const complex& x){

Returnx.imag ();

}

后面出现的不在本体的部分也可以加inline？？？？？

Access level访问级别

在类声明中可以分为public和private。

什么要放在private?数据部分！为了封装起来，函数要看具体，还有protected。段落可以任意出现也可以交错，比如有好几个public。

数据都应该放在private，函数内部处理可放在private,被外界调用可放在Public.

构造函数，自动调用(constructor)

complex (double r = 0, double I = 0)

:re{r}, im(i)

{ }

complex c1(2,1);

complex c2;

complex* p = new complex(4);

-构造函数名称一定和函数名称相同

-一定有参数

-参数可以有默认值double r = 0,double I = 0

-其他函数也可以有默认值！！！defaultargument

-构造函数没有返回类型

-赋值部分不要写在大括号里，利用只有构造函数可以用的语法

: re (r), im (i)初值列，初始列和赋值re = r; im

= I;一样的意义。

数值的设定有两阶段，一个是初始化，一个是赋值，所以使用这种更为有意义？？

写在下面相当于放弃了初始化的阶段。

-析构函数，不带指针的类多半不需要写析构函数

构造函数可以有很多个。C++允许同一个函数多个出现，overloading因为输入参数不同

有很多种初值的设定。

Double real () const {return re;}

Void real (double r) {re = r;}

编译器编译后的实际名称可能是：

?real@Complex@@QBENXZ

?real@Complex@@ZARNABN@Z

新加的构造函数

complex () : re(0), im(0) {}

这样是不行的！！！！！！！

因为第一个构造函数有默认值

complex c1;

complex c2();

编译器会发现两个构造函数都可以调用，所以会报错。

-函数可以重载，输入类型不同

-函数重载常常会发生在构造函数上。

-像上面那样有默认值的如果两个同时可以调用就不行。

D参数传递与返回值

构造函数放在private区域会怎么样？？

此时complex c1(2,1);

complex c2;就都不对

什么时候要这样做？不允许被外界创造对象。

设计模式Singleton

class A{

public:

staticA& getInstance();

setup(){}

private:

A();

A(constA& rhs);

…

}

A& A::getInstance(){

Static A a;

Returna;

}

A::getInstance().setup();

把构造函数写在private里叫Singleton

函数部分

double real () const {return re;}

double imag () const {return im;}

const的位置！！！！！

这两个函数不改变值，class里的函数有改变数据内容和不改变数据内容，不改变数据内容的函数马上加const。不加的后果：

complex c1(2, 1);

cout << c1.real();

cout << c1.imag();

const complex c1(2,1);

cout << c1.real();

cout << c1.imag();

下面的情况，complex是一个常数不可以改变，在用两个函数去调用的时候，如果函数里没写const说明函数可能会改data，编译器就会报错。Const可以用来修饰函数，可以用来修饰变量。

参数传递，pass by value vs. pass by reference(to const)

complex (double r = 0, double I = 0) passby value

complex & operator += (constcomplex&); pass by ref to const

operator << (ostream & os, constcomplex& x) pass by ref, pass by ref to const

-pass by value是把整个值传过去，几个字节就几个字节。

-传引用就相当于传指针那么快，形式很漂亮。

Complex c1(2,1);

Complex c2;

C2 += c1;

Cout << c2;

-最好所有参数的传递都传引用，字节固定，四个字节。

传引用，你改完会影响我。所以要看具体情况，但如果传过去只是为了速度，但不希望你改了会影响我，这时候可以用const.保证传给你后你不能改，你改了会影响我，此时如果传过去后被改了编译器会出错。

-参数传递尽量都传引用。

-如果想的细，比引用字节少，也可以传值。

Operator << (ostream& os, constcomplex& x)

第一个没有const说明允许改。

返回值传递return by value vs. return reference(to const)

coplex& operator += (constcomplex&);

double real () const {return re;}

double imag() const {return im;}

friend complex& __doapl (complex*,const complex&);

返回值尽量也传ref，在可以的情况下。

Friend(友元)

Friend complex& __doapl (complex*,const complex&);

朋友可以来拿数据。

Private外界不可以接触数据

Inline complex&

__doapl (coplex* ths, const complex&r){

ths->re+= r.re;

ths->im+= r.im;

return*ths;

}

相同class的各个objects互为友元

int func(const complex& param)

{return param.re + param.im;}

当类里的函数输入类型是该类的话可以直接拿里面的数据，为什么？？

看起来打破了封装，但是成立的。

Complex c1(2,1);

Complex c2;

C2.func(c1);

Class body外的各种定义definitions

-数据一定放在private里

-参数尽可能以ref来传，要不要加const看状况

-返回值尽量也用ref来传

-类的body里要加const的地方要加。

-构造函数initialization

list，冒号

什么情况下不能return by ref呢？

Inline complex&

__doapl (complex* ths, const complex&r){

ths->re+= r.re;

ths->im+= r.im;

return *ths;

}

加出来的结果是放在新创建来的地方还是放在已有的地方，如果是新生成的，在函数返回的时候就消失了，此时不能使用ref。除了这种情况都可以返回ref

inline complex&

complex::operator += (const complex&r){

return __doapl(this, r)

}

E．操作符重载与临时对象

头文件的防卫式声明，

C++中允许对操作符进行重载，比如让加法支持复数。

成员函数：this

c2 += c1

+=是一个二元操作符，编译器看到后会作用在左边上，

inline complex&

complex::operator += (this, constcomplex& x){

return __doapl (this, r);

}

this是隐藏的部分，不写，所有的成员参数一定带有一个隐藏的参数，叫this,谁调用这个函数谁就是this，这里c2就是this，this是一个指针，编译器会自动把c2的地址传进来当做this,写代码的时候不必写也不能写this，不影响我们写代码，不能再参数列里写出来，但在函数中可以用。

Return by ref语法分析

传递者不需要知道接受者是以ref形式接受的。

Inline complex&

__doapl(complex* ths, const complex&){

return *ths;

}

&写在后面和写在前面不一样，在后面是取得来的value的地址。

+=是将后面的值加到前面，所以理论上一个+=运算符是可以返回void，但如果使用c3 +=

c2 +=c1就会有问题，所以返回complex&更合理，可以进行多步操作。

所有的上面都是头文件里面类的定义部分

class complex{

…

}

下面是第二部分，成员函数和全域函数

inline double

imag(const complex& x){

return x.imag();

}

操作符冲重载非成员函数

c2 = c1 + c2;

c2 = c1 +5;

c2 = 7 + c1;

编译器回去找调用哪个

三种写法，所以要有三个函数

inline complex

operator + (const complex& x, constcomplex& y){

return complex((real(x) + real (y), imag(x) + imag(y));

}//复数加复数

全域函数，没有this pointer???

这三个函数都是返回value，为什么不用ref返回？

他们返回的不能是ref，因为他们返回的必定是个local object，之前是右边加到左边，左边已经存在，现在需要先创建一个左边的空间来存放数据，离开该函数后这个地址就失效了。叫temp object。

在上面函数中都没有定义complex，return complex();

typename（）；

这样的做法是创建临时对象，它的生命到下一行就结束了。

比如

complex();

complex(4, 5);

cout << complex(2);

比较特殊，一般人少用，但标准库很常用。

Negate

Inline complex

Operator + const complex& x){

Return x;

}

inline complex

operator – (const complex& x){

returncomplex (-real (x), -imag (x));

}

区别由输入的参数不同来区别，

negate返回的是一个新的东西，所以不能返回ref，但是上面的正好表示什么都不变，所以并没有产生新的结果，所以对于正号操作应该可以传回ref。

==

cout << (c1 == c2);

cout << (c1 == 2);

cout << (2 == c1);

考量输入有没有用ref，返回能否使用ref，

共轭复数，实部相等，虚部符号相反，

inline complex

conj (const complex& x){

return complex(real(x), -imag(x));

}

任何一个函数都可以有两种想法，全域函数或者成员函数。

#include

ostream&

operator << (ostream& os, constcomplex& x){

return os<< ‘(’ << real (x) << ‘,’ << imag (x) << ‘)’;

}

cout << conj(c1);

对于output operator绝对不能写成一个成员函数

cout << c1 << conj(c1);

不能加const，因为ostream& os需要改变，所以不能加。按照道理，输出<<后面的值赋给前面后就没事了，所以可以返回值是void，但是当像上面一样连用后就不能返回void了。再去考虑返回的是by value还是by ref，发现返回的是原来的东西，所以用ref，再考虑要不要加const，发现改变了结果，所以不能加const。

重点复习

-构造函数的initialization：re(r), im(i)

-函数要不要加const

-参数的传递尽量考虑pass by ref,而且要不要加const要考虑

-return的时候是ref还是value

-你的数据几乎没有例外要放在private，而函数大部分要放在public，因为函数大部分要被外界调用。

Complex类

Week1总结

在写一个date类的过程中，我的写过程：

先声明宏定义，这个定义是为了防止重复引用头文件，在宏的名称命名规则上，系统内的宏一般以下划线或者双下划线开头，在我们自己定义宏的时候，尽量避免使用下划线开头，此处使用MYDATE

然后，到了视频中所说的头文件的第0部分，主要有下面要定义的类的声明和全局函数的声明。较为简单。然后到了头文件的第2部分，类的声明和类内成员函数的声明，注意的地方富有：在写构造函数的时候，使用数据的初始化，具体原理为在构造一个新的函数时，有初始化和赋值两部分组成，写在此处的: re(r), im(m) { }是一个初始化的过程，可以将两部完整的分开，更加合理。后面的大括号里面可能是一些文件的读写过程。这个初始化的方法是类内独有的，注意不要在其他地方使用。在写类内成员函数的时候，需要注意的有输入是否传引用还是传值，包括返回值是传引用还是传值。规则是，当输入基本都可以传引用，但如果分的细在小于4字节的值传递时传值更加有效率，返回值当传回的值为新建的时候需要传值（临时建立，结束函数后即消失），原有的输入更改时传引用。除此以外，在函数前面要注意是否改变类内的值，如果没有改变要加const。具体还有如果将构造函数写在private里是singleton的设计模式，在某些只允许有一个对象存在时可以使用，使用singleton设计模式时要注意通过成员函数将对象传出。

再到函数的第三部分

重构成员函数和全局函数，第一返回值前面可以加inline表示当函数比较小时，具体定义方法在类内就定义好调用时可以增加效率，但具体能不能inline是编译器决定的.

在写date函数时，有一个createpoints函数需要随机生成10个日期，在这个过程中我遇到了如何随机生成值得问题，使用了srand函数和rand()函数，每当使用srand设定一次种子，rand（）函数重新生成会得到同样的值，导致一开始我在每次随机时都srand一次，得到了10个同样的值，后来只在一开始srand，每次rand()的值就不一样了。

再是在排序的时候我使用了冒泡排序，当找到最小值后，我没有想就写了将一个日期等于另一个日期，编译后发现不对，对于新建立的类内没有定义=的用法，需要在类内增加一个对于date类的=用法或者设定一个新的方法可以将一个对象的值赋给另一个对象，后来我设计了setvalue的方法用于赋值。

现在我遗留的问题有，在对complex类的例子里对于友元friend的设定可以是一个函数的意思是吗？因为以前只有接触过定义某个类是这个类的友元，则其private里的函数和值可以被其他类内直接调用，不知道我的理解对不对，即对某个函数定义为该类的友元，则在该全局函数里可以调用类内的private里的值或函数。

在这第一个学期的学习里，知道了写头文件的时候的一些约定俗成的方法和段落，以及定义一个类和方法的一些规则。