一 编程设计
1.将程序划分为多个子系统,包括子系统间的接口和依赖关系、子系统间的数据流、在各子系统间的来回输入输出、以及总的线程模型。
2.各个子系统的具体细节，包括进一步细分的类、类层次体系、数据结构、算法、特定的线程模型和错误处理。
二 设计流程
1.需求:功能需求和性能需求。
2.设计步骤
(1)把程序划分为通用功能子系统，并明确子系统的接口和交互。
(2)把这些子系统列在一个表中，并表示出子系统的高层行为或功能、子系统向其它子系统提供的接口,及此子系统使用了其他子系统的哪些接口。
(3)选择线程模型:确定使用多少个线程，明确线程的交互并为共享数据指定加锁机制。
(4)为每个子系统指定层次体系
(5)为每个子系统指定类、数据结构、算法和模式
(6)为每个子系统指定错误处理(系统错误 + 用户错误),指定是否使用异常
三 C++ 的设计原则
1.抽象:将接口与实现相分离
2.重用:代码重用和思想重用
四 对象关系
1.has-a 关系(聚集)
2.is-a 关系(继承)
3.组织对象层次体系:
(1)将类按有意义的功能加以组织。
(2)将共同的功能放到超类中,从而支持代码重用。
(3)避免子类过多的覆盖父类的功能。
五 重用设计
1.建立可重用的代码结构
(1)避免将无关或逻辑上分离的概念混在一起
(2)把程序划分为子系统
(3)使用类层次体系来分离逻辑概念
(4)使用聚集来分离逻辑概念
(5)对通用数据结构和算法使用模板
(6)提供适当的检查和防护
六 设计易于使用的接口
1.开发直观的接口
2.不要遗漏必要的功能
3.提供简洁的接口
(1)消除重复的接口
(2)只提供所需的功能
(3)适当的限制库的使用
4.提供文档和注释
(1)公共的文档应指定行为,而不是底层实现
七 设计通用的接口
1.提供多种方法来完成同一功能
2.提供定制能力
八 协调一般性和通用性
1.提供多个接口
2.优化常用功能
九 代码注释
(1)前缀注释
* 文件/类名
* 最后一次修改时间
* 原作者
* 文件所实现特性的编号 (特性 ID)
* 版权信息
* 文件/类的简要描述
* 未完成的特性
* 已知的 bug
(2)注释示例
/*
* Watermelon.cpp
*
* $Id: Watermelon.cpp,v 1.6 2004/03/10 12:52:33 klep Exp $
*
* Implements the basic functionality of a watermelon. All
* unit are expressed in terms of seeds per cubic centimeter
* Watermelon theory is based on the white paper "Alogorthms
* for Watermelon Processing."
*
* The following code is (c)copyright 2004. FruitSoft, Inc.
* All right reserved
*/
十 编写代码
1.类定义在 C++ 中是一条语句,因此必须以分号结束。
2.:: 指作用域解析操作符。
3.在栈和堆上使用对象的区别
(1)在栈上创建对象
SpreadsheetCell myCell, anotherCell;
(2)在堆上使用对象
SpreadsheetCell *myCellp = new SpreadsheetCell();
(3)如果用 new 来分配一个对象,用完该对象时要用 delete 来释放
4.C++ 程序员通常把构造函数称为 "ctor"
5.使用构造函数
(1)在栈上使用构造函数
SpreadsheetCell myCell(5);
(2)在堆上使用构造函数
SpreadsheetCell *myCell = new SpreadsheetCell(5);
delete myCell;
(3)不要尝试从类的一个构造函数调用另一个构造函数
6.使用默认构造函数
(1)在栈上使用构造函数
SpreadsheetCell myCell; //right
SpreadsheetCell myCell();//wrong
(2)在栈上创建对象时,要去掉默认构造函数的小括号
(3)在堆上使用默认构造函数
SpreadsheetCell *myCellp = new SpreadsheetCell();
(4)什么时候需要使用构造函数
SpreadsheetCell cells[3];//fails comilation without default ctor
SpreadsheetCell *myCellp = new SpreadsheetCell[10];//alse fails
(5)使用初始化列表
1)初始化列表允许在创建数据成员的同时完成数据成员的初始化
2)使用初始化列表的情况
数据成员 解释
------------------------------------------------------------------
const 数据成员 必须在创建时提供值
引用数据成员 引用无法独立存在
没默认构造函数的对象成员 对象成员无法初始化
没有默认构造函数的超类 见后面
------------------------------------------------------------------
7.对象的撤销
(1)析构函数仅用于释放内存或释放其他资源是一个不错的想法
8.浅复制与深复制
(1)浅复制:只是从源对象直接将数据成员复制或赋值到目标对象
(2)深复制:非浅复制
(3)只要在类中动态分配了内存,就应该编写自己的复制构造函数来提供内存的深复制
(4)在对一个对象进行赋值前,必须先释放此对象的所有动态分配的内存
(5)只要类会动态分配内存,就需要编写析构函数、复制构造函数、赋值操作符
(6)禁止对象赋值,可将复制构造函数与赋值操作符声明为私有成员
(7)不必为私有复制构造函数和赋值操作符提供实现,编译器不要求
十一 精通类和对象
1.不能在静态方法中访问非静态数据成员
2.保证一个对象不会修改数据成员,可用 const 来标记
3.保证一个方法不会修改数据成员,可用 const 来标记
(1)在类定义中的声明 double getValue() const;
(2)在源文件中的实现
double Spreadsheet::getValue() const
{
return this.mValue;
}
4.非 const 对象可以调用 const 和非 const 方法,const 对象只能调用const 方法
5.应将所有不会修改对象的方法都声明为 const,并在程序中使用 const对象引用
6.将变量置为 mutable,这样编译器允许在 const 方法中修改这个变量
7.C++ 不允许仅基于方法的返回类型而重载一个方法名
8.默认参数:从最右参数开始的连续参数表
9.只能在方法声明中指定默认参数,在定义中并不指定
10一个构造函数的所有参数都有默认值,此函数会作为默认构造函数
11能利用默认参数做到的事情,利用方法重载也可以做,用你最熟悉的
12内联:将方法体或函数体直接插入到代码调用处(相当于 #define 宏的安
全版本),内联示例如下:
(1)在类的源文件(SpreadsheetCell.cpp)
inline double SpreadsheetCell::getValue() const
{
mNumAccess++;
return mValue;
}
(2)或在类的声明文件中直接实现此方法而不用 inline 关键字
//SpreadsheetCell.h
double getValue() const (mNumAccesses++; return mValue;}
13友元可以访问指定类中的 protected 和 private 数据成员和方法
(1)声明友元类
class SpreadsheetCell
{
public:
friend class Spreadsheet;
//code omitted here
};
(2)声明友元方法
class SpreadsheetCell
{
public:
friend bool checkSpreadsheetCell();
//code omitted here
};
十二 C++ 中的继承机制
1.超类指针(引用)在引用子类时，了类仍然会保留它们覆盖的方法。而在
强制类型转换成超类对象时，子类会失去它们的独有特性。覆盖方法和子
类数据的丢失称为切割。
2.作为一条经验，要把所有的方法都用 virtual 声明 (包括析构函数，但
是不包括构造函数) 来避免因遗漏关键字 virtual 而产生的相关问题。
3.virtual 用法示例:
class Sub : public Super
{
public:
Sub();
virtual void someMethod();
virtual void someOtherMethod();
}
4.要把所有的析构函数都用 virtual 声明
5.强制类型转换
(1)静态转换 static_cast<type>
示例:
Sub* mySub = static_cast<Sub*>(inSuper);
(2)动态转换 dynamic_cast<type>
示例:
Sub* mySub = dynamic_cast<Sub*>(inSuper);
if (mySub == NULL)
{
//proceed to access sub methods on mySub
}
注意:如果对指针不能进行动态类型转换，指针则为 NULL, 而不是指
向无意义的数据。
6.进行向上强制类型转换时,要使用指向超类的指针或引用来避免切割问题。
7.纯虚方法与抽象基类
(1)纯虚方法: 在类定义中显示未定义的方法。
(2)抽象类: 含有纯虚方法的类(不能实例化)。
(3)纯虚方法语法定义: 在类定义中简单的设置方法等于 0,在 cpp 文件
中不要编写其实现代码。
示例:
class SpreadsheetCell
{
public:
SpreadsheetCell();
virtual ~SpreadsheetCell();
virtual void set(const std::string instring) = 0;
virtual std::string getString() const = 0;
};
8.定制类型转换函数
(1)double 类型转换成 string 类型
#include <iostream>
#include <sstream>
double inValue;
string myString;
ostringstream ostr;
ostr << inValue;
myString = ostr.str();
(2)string 类型转换成 double 类型
#include <iostream>
#include <sstream>
double myDouble;
string inString;
istringStream istr(inString);
istr >> myDouble;
if (istr.fail())
{
myDouble = 0;
}
9.使用预编译指令避免重复包含头文件
#ifndef _TEST_H_
#define _TEST_H_
// include header files here
// other code omitted here
#endif
十三 覆盖方法的特殊情况
1.在 C++ 中不能覆盖静态方法。
(1)不能同时用 virtual 和 static 声明一个方法。
(2)在对象上可以调用 static 方法，但 static 方法只存在于类中。
十四 利用模板编写通用代码
1.模板相关概念
(1)类模板: 存储对象的容器或数据结构。
(2)模板的语法:
template <typename T>
class Grid
{
public:
Grid(int inWidth, int inHeight);
Grid(const Grid<T>& src);
Grid<T>& operator=(const Grid<T>& rhs);
T& getElementAt(int x, int y);
const T& getElementAt(int x, int y);
void setElementAt(int x, int y, const T& inElem);
protected:
void copyFrom(const Grid<T>& src);
T** mCells;
};
(3)语法解释
template <typename T> : 指在类型 T 上定义的模板。
Grid<T> : Grid 实际上是模板名。
Grid<T> : 将作为类模板中的类名。
(4)模板定义(实现)
template <typename T>
Grid<T>::Grid(int inWidth, int inHeight)
{
mCells = new T* [mWidth];
for (int i = 0; i < mWidth; i++)
{
mCells[i] = new T[mHeight];
}
}
(5)模板实例化
Grid<int> myIntGrid;
十五 C++ 中的一些疑难问题
1.引用
(1)定义: 另一个变量的别名, 对引用的修改会改变其所指向的变量。
(2)引用变量必须在创建时就初始化。
int x = 3; // right
int& xRef = x;// right
int& emptyRef;//wrong
注: 类的引用数据成员可在构造函数的初始化列表中初始化。
(3)不能创建指向未命名值的引用(const 常量值除外)
int& unnameRef = 5; //does not compile
const int& unnameRef = 5;//works as expect
(4)修改引用: 引用总是指向初始化时指定的那个变量。
int x = 3, y = 4;
int& xRef = x;
xRef = y; // change x value to 4, doesn't make refer to y;
xRef = &y; // doesn't compile, type not match
注: 引用指向的变量在初始化之后不能再改变, 只能改变此变量的值
(5)指针引用和引用指针
//指针引用示例(指向指针的引用)
int* intP;
int*& ptrRef = intP;
ptrRef = new int;
*ptrRef = 5;
注:不能声明指向引用的引用, 也不能声明引用指针(指向引用的指针)
int x = 3;
int& xRef = x;
int&& xDoubleRef = xRef; // not compile
int&* refPtr = &xRef; // not compile
(6)传引用vs传值
1)效率。复制大对象和结构要花费很长时间。
2)正确性。不是所有的对象都允许传值或正确的支持深复制。
3)不想修改原对象，又利用以上两优点，可在参数前加 const。
4)对简单内置类型(如int或double)要传值,其它所有情况可传引用。
(7)引用vs指针
1)引用让程序清晰，易于理解。
2)引用比指针安全，不存在无效的引用，不需要明确解除引用。
3)除非需要动态分配内存或在其它地方要改变或释放指针指向的值，否则都应使用引用而非指针。
2.疑难字 const
(1)const 变量
使用 const 来声明变量，对不能对其修改，以保护变量。
(2)const 指针
//不能改变指针指向的值
const int* ip;
ip = new int[10];
ip[4] = 5; // not compile
或
int const* ip;
ip = new int[10];
ip[4] = 5; // not compile
//不能改变指针自身
int* const ip;
ip = new int[10]; // not compile
ip[4] = 5;
//既不能改变指针也不能改变指针指向的值
const int* const ip = NULL;(无用的指针)
注: const 可以放在类型前也可以放在类型后
(3)const 应用规则
const 应用于其左则的第一项。
(4)把对象参数传递时，默认的做法是把传递 const 引用。
(5)const 方法
用 const 标识类方法，可以防止方法修改类中不可变的数据成员。
3.关键字 static
(1)关于连接: C++ 中的每个源文件是独立编译的，得到的对象连接在一
起。
(2)外部连接: 一个源文件中每个名字(如函数或全局变量)对其它源文件
是可用的。
(3)内部连接: 一个源文件中每个名字(如函数或全局变量)对其它源文件
是不可用的。内部连接也叫静态连接。
(4)函数和全局变量默认是外部连接。
(5)声明前加 static 可指定为内部连接。
4.关键字 extern
(1)作用: 与 static 相对，用来为位于它前面的名字声明外部连接。
(2)extern 用法
// AnotherFile.cpp
extern int x; // 只是声明 x 为外部连接而不分配内存
int x = 3; //显示定义以分配内存
或
extern int x = 3;//声明和定义一起完成
//FirstFile.cpp
extern int x;
cout << x << endl;
5.强制类型转换
(1)const_cast<type> 去除变量的常量性。
示例:
void g(char* str)
{
// body omitted here
}
void f(const char* str)
{
g(const_cast<char*>(str));
// other code omitted here
}
(2)static_cast<type> 显示的完成 C++ 语言支持的转换。
示例:
int x = 3;
double result = static_cast<double>(i) /10;
注: static_cast 进行类型转换时并不完成运行时类型检查。
(3)dynamic_cast<type>
1)对类型强制转换完成运行时类型检查。
2)对指针转换失败时会返回 NULL。
3)对引用转换失败时会抛出 bad_cast 异常。
6.函数指针
(1)定义: 把函数地址作为参数,可以像变量一样使用。
(2)定义函数指针: typedef bool(*YesNoFcn) (int, int);
(3)用法示例
//定义函数指针类型
typedef string(*YesNoFcn)(int, int);
void test(int value1, int values2, YesNoFcn isFunction)
{
cout << isFunction(value1, value2);
}
string intEqual(int intItem1, int intItem2)
{
return (intItem1 == intItem2) ? "match" : "not match";
}
//使用函数指针
test(1, 1, &intEqual);
注: & 是可选的
十六 C++ 中的 I/O 操作
1.使用流
(1)每个输入流都有一个相关联的源，每个输出流都有一个相关联的目的。
(2)cout 和 cin 都是在 C++ 的 std 命名空间中预定义的流实例。
(3)流的三种类型:
1)控制台输入输出流。
2)文件流。
3)字符串流。
(4)输出流
1)输出流在头文件 <ostream> 中定义，输入流在 <istream> 中定义<iosream> 中定义了输入输出流。
2)cout 和 cin 指控制台输入输出流。
3)<< 操作符是使用输出流的最简单的方法。
4)流其它的输出方法
1)put() 和 wirte()
2)flush() 刷新输出
5)处理输出错误
1)cout.good() 流是否处于正常的可用状态。
2)cout.bad() 流输出是否发生了错误。
3)cout.fail() 如果最近的操作失败则返回 true
4)cout.clear() 重置流的错误状态
6)输出控制符
1)endl 输出回车并刷新其缓冲区
2)hex oct dec 以十六/八/十进制输出
3)setw 设置输出数值数据时的字段占位符
4)setfill 设置填充空位的占位符
(5)输入流
1)>> 输入流操作符
2)输入方法
1)get() 仅仅返回流中的下一个字符
2)unget() 引起流回退一个位置
3)peek() 预览下一个值
4)getline() 从输入流中取一行数据
3)处理输入错误
1)good()
2)eof()
(6)字符串流
1)<ssteam> 定义了字符串流的头文件
2)ostringstream 字符串输出流
3)istringstream 字符串输入流
(7)文件流
1)<fstream> 定义了文件流的头文件
2)ifstream 文件输入流
3)ofstream 文件输出流
4)seek() 定位流的位置
5)tell() 查询流当前的位置
(8)链接流
1)定义: 在任何输入流与输出流之间建立连接，一旦访问就刷新输出。
2)实现: 用输入流的 tie() 方法
3)示例
#include <iostream>
#inlcude <fstream>
#include <string>
main()
{
ifstream inFile("input.txt");
ofstream outFile("output.txt");
//set up a link between inFile and outFile.
inFile.tie(&outFile);
string nextToken;
inFile >> nextToken;
}
十七 C++ 中的异常
1.抛出和捕获异常
(1)<exception> 定义异常类的头文件。
(2)抛出异常对象 throw exception()
(3)向量的使用(整型)
vector<int> myInts;
for (int i = 0; i < 10; i++)
{
myInts.push_back(i);// 增加元素
cout << myInts[i];
}
(4)string 风格的字符串转换成 C 风格的字符串
string myString = "string style string";
char* cStyleStrng = myString.c_str();
(5)捕获运行时异常
try
{
...
}
catch (const runtime_error& e)
{
...
}
(6)抛出和捕获无效参数异常
throw invalid_argument("");
try
{
...
}
catch (const invalid_argument& e)
{
...
}
注: runtime_error 和 invalid_argument 定义在头文件<stdexcept> 中
(7)匹配任何异常(...)
try
{
// code omitted here
}
catch (...)
{
// code omitted
}
注: 不建议使用这种方式
(8)使用抛出列表
1)抛出列表: 一个函数或方法能抛出的异常列表
2)必须为函数声明和实现都提供抛出列表
3)没有抛出列表就可以抛出任何异常
4)空的抛出列表不允许抛出任何异常
(9)在覆盖方法中修改参数列表
1)从列表中删除异常
2)增加超类抛出列表中异常的子类
3)不能完全删除抛出列表
(10)显示异常消息
可调用 exception 或子类的 what() 方法显示捕获到的异常消息
示例:
try
{
...
}
catch (const exception& e)
{
cerr << e.what() << endl;
exit(1);
}
(11)多态地捕获异常
1)在多态地捕获异常时，要确保按引用捕获异常。如果按值捕获异常，就会遇到切割问题，丢失对象的信息。
2)按引用捕获异常可以避免不必要的复制开销
(12)如果异常处理不够仔细,就会导致内存和资源泄漏
示例
func ()
{
string str1;
string* str2 = new string();
throw exception();
delete str2; // 内存泄漏
}
(13)使用智能指针防止内存泄漏
#include <memory> // 定义智能指针的头文件
using namespace std;
func ()
{
string str1;
// 智能指针,不用自己手动释放
auto_ptr<string> str2(new string("hello"));
throw exception();
}
(14)处理内存分配错误
1)new 和 new [] 分配内存失败默认抛出 bad_alloc 异常
2)可用 try/catch 捕获异常处理内存分配失败
3)示例:
try
{
ptr = new int[numInts];
}
catch (bad_alloc& e)
{
cerr << "Unable to alloc memory!" << endl;
return ;
}
或
1)用 new(nothrow) 在内存分配失败时返回 NULL 来处理
2)示例:
ptr = new(nothrow) int[numInts];
if (ptr == NULL)
{
cerr << "Unable to alloc memory!" << endl;
return;
}
或
1)用 set_new_handler() 回调函数定制分配失败时的行为
2)示例
void myNewHandler()
{
cerr << "Unable to allocate memory!" << endl;
abort(); // 终止程序 <cstdlib>
}
#include <new>
#include <cstdlib>
#include <iostream>
using namespace std;
int main(int argc, char** argv)
{
new_handler oldHandler = set_new_handler(myNewHandler);
// code omitted here
set_new_handler(oldHandler);
return (0);
}
1420
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
