Notes Of CourseraPOP（To be continued ~）-优快云博客

本文链接：https://blog.youkuaiyun.com/awyd234/article/details/41312183

此文为北大coursera课程《程序设计实习》（郭炜+刘家瑛主讲）个人笔记

Week 01 从C走进C++

01 FunPtr

类型名(* 指针变量名)(参数类型1, 参数类型2, ...);

函数指针名（实参表）;

void 
PrintMin(int a, int b)
{
	if (a < b) {
		printf("%d\n", a);
	} else {
		printf("%d\n", b);
	}
}

int main()
{
	void(*pf)(int, int);
	int x = 4, y = 5;
	pf = PrintMin;
	pf(x, y);
	system("pause");
	return 0;
}

qsort函数：

void qsort(void *base, int nelem, unsigned int width, int(*pfCompare(const void*, const void*)));

比较函数规则： *elem1 排在 *elem 2 之前，返回负整数

*elem1 与 *elem 2 顺序无所谓，返回0

*elem1 排在 *elem 2 之后，返回正整数

02 CmdPara

获得命令行参数的程序main函数必须为 int main(int argc, char * argv[]) {...}

argc：代表程序启动时，命令行参数的个数。可执行程序本身文件名也算一个命令行参数。

argv：指针数组，每个元素都是一个char* 类型指针，指针指向一个字符串，存放着命令行参数。

03 BitOpr

右移运算符 “>>”，结果往小里取整，对有符号数为算数右移

eg：两个int型变量a, b (0<=n<=31)，写表达式使和a的第n位相同

1. (a >> n) & 1

2. (a & (1 << n)) >> n

04 Refer

定义引用时，一定需要初始化为引用某个变量，且只能引用变量，不能引用常量或表达式

// C中交换int变量
void
swap(int *a, int *b)
{
	int tmp;
	tmp = *a; *a = *b; *b = tmp;
}
int n1, n2;
swap(& n1, & n2);

// C++引用
void
swap(int& a, int& b)
{
	int tmp;
	tmp = a; a = b; b = tmp;
}
swap(n1, n2);

还可以引用作为函数返回值

int n = 4;
int& 
SetValue()
{
	return n;
}

int main()
{
	SetValue() = 40;
	std::cout << n;
	return 0;
}

常引用：int n = 100; cont int &r = n; 不能通过常引用去修改其引用内容

05 Const

不可通过常量指针修改其指向内容

不能把常量指针赋给非常量指针，反过来可以

函数参数为常量指针时，可避免函数内部不小心改变参数指针所指地方内容

06 Dynamic

动态内存分配：

P = new T;

P = new T[N];

用 “new” 动态分配的内存空间，一定要用 "delete" 运算符释放

delete 指针;

delete [] 指针;

07 InlineFunctions

内联函数：把整个函数的代码插入到调用语句处，而不会生成调用函数语句。

函数重载：一个或多个函数，名字相同，参数个数或参数类型不同。

08 DefaultArg

eg: void func(int x1, int x2 = 2, int x3 = 3) { }

只能最右边的连续若干个参数缺省。

Week 02 类和对象初探

01 BasicExample

对象的内存空间

对象的大小 = 所有成员变量的大小之和

每个对象各有自己的存储空间

访问类的成员函数和成员变量

Method 1：对象名.成员名

Method 2：指针 -> 成员名

Method 3：引用名.成员名

02 ClassMember

关键字 -- 类成员可被访问范围

private: 只能在成员函数内访问

public: 可在任何地方被访问

protected

三种关键字出现次数与先后顺序无限制

03 Constructor

对象生成时构造函数自动被调用，对象一旦生成，就再也不能在其上执行构造函数

只要生成对象，不论以什么方式生成，都会调用构造函数

一个类可以多个构造函数（重载）

04 History

05 Inline & Override

内联成员函数：

1. 关键字(inline)+成员函数

2. 整个函数体出现在类定义内部

使用缺省参数要注意避免有函数重载时的二义性

05 OODesign

Week 03 类和对象进阶

01 CopyCons

复制（拷贝）构造函数：

只有一个参数，即对同类对象的引用

有默认的，也可以自己定义 eg: Complex(const Complex & c) { ... } // const 可不加

起作用的三种情况：

1. 当用一个对象去初始化同类的另一个对象时

2. 如果某函数有一个参数为类A的对象，那么该函数被调用时，类A的复制改造函数将被调用

3. 如果函数的返回值为类A的对象时，则函数返回时，A的复制构造函数被调用

02 TypeConversion

类型转换构造函数：

实现类型自动转换

只有一个参数，且不是复制构造函数

class Complex {
public:
	double ral, imag;
	Complex(int i)		// 类型转换构造函数
	{
		cout << "IntConstructor called" << endl;
		ral = i;
		imag = 0;
	}
	Complex(double r, double i)
	{
		ral = r; imag = i;
	}
};

int main()
{
	Complex c1(7, 8);
	Complex c2 = 12;	// 初始化，非赋值
	c1 = 9;				// 9被自动转换成一个临时Complex对象,赋给了c1
	cout << c1.ral << "," << c1.imag;
	system("pause");
	return 0;
}

03 Destructor

先被构造的对象最后析构

04 StaticMem

静态成员：在说明前面加了static关键字的成员

静态成员变量一共就一份，被所有对象共享，sizeof运算符不会计算静态成员变量

静态成员函数并不具体作用于某个对象

静态成员不需要通过对象即可访问，访问方法：

1、类名::成员名

2、对象名.成员名

3、指针->成员名

4、引用.成员名

静态成员变量为全局变量，哪怕一个对象都不存在，类的静态成员变量也存在

静态成员函数本质上为全局函数

设置目的是将和某些紧密相关的全局变量和函数都写到类里面，看上去像一个整体，易于维护和理解。

必须在定义类的文件中对静态成员变量进行一次说明或初始化，否则编译能通过，链接不能通过。

静态成员函数中，不能访问非静态成员变量，也不能调用非静态成员函数

05 MemObj

成员对象：一个类的成员变量是另一个类的对象

包含成员对象的类叫封闭类

封闭类构造函数的初始化列表：

定义封闭类的构造函数时，添加初始化列表：

类名::构造函数（参数表):成员变量1(参数表), 成员遍历2(参数表), ...

{

...

}

c成员对象初始化列表中的参数：

任意复杂的表达式，或函数 / 变量 / 表达式中的函数，变量有定义

class CTyre {
private:
	int radius;
	int width;
public:
	CTyre(int r, int w) :radius(r), width(w) {}   // 初始化列表
};

class CEngine {

};

class CCar {		// 封闭类
private:
	int price;
	CTyre tyre;
	CEngine engine;
public:
	CCar::CCar(int p, int tr, int w) :price(p), tyre(tr, w) {}
};

封闭类对象生成时，调用顺序：S1：执行所有成员对象的构造函数

S2：执行封闭类的构造函数

封闭类的对象消亡时，析构函数顺序反之

成员对象的构造函数调用顺序：和成员对象在类中的说明顺序一致

和在成员初始化列表中出现的顺序无关

06 Friend

友元函数：一个类的友元函数可以访问该类的 私有成员，类中函数前加关键字 friend

// 一个类的友元函数可以访问该类私有成员
class CCar;

class CDriver {
public:
	void ModifyCar(CCar * pCar);
private:

};

class CCar {
private:
	int price;
	friend int MostExpensiveCar(CCar cars[], int total);  // 声明友元
	friend void CDriver::ModifyCar(CCar * pCar);
};


// 将一个类的成员函数（包括构造，析构）定义为另一个类的友元
class B {
public:
	void function();
};

class A {
	friend void B::function();
};

友元类：A是B的友元类，则A的成员函数可以访问B的私有成员，友元类的声明在B类中，即 friend class A;

友元类之间的关系，不能传递，不能继承

07 ThisPtr

this指针：作用就是指向成员函数所作用的对象

非静态成员函数中可以直接使用this指针来代表指向该函数作用的对象的指针

静态成员函数中不能使用this指针：静态成员函数并不具体作用于某个对象

静态成员函数的真实参数的个数，就是程序中写出的参数个数

class A {
	int i;
public:
	void Hello() {
		//cout << "hello" << endl;			// 输出hello
		cout << i << "hello" << endl;		// 出错
	}// -> void Hello(A *this){ cout << "hello" << endl; }
};

int main()
{
	A *p = NULL;
	p->Hello();
	return 0;
}

08 ConstObj

常量对象：如果不希望某个对象的值被改变，则定义该对象的时候可在前面加const关键字

常量成员函数：在类的成员函数说明后面可以加const关键字，则该成员函数为常量成员函数

常量成员函数执行期间不应修改其作用的对象

在常量成员函数中不能修改成员变量的值，也不能调用同类的非常量成员函数，静态成员变量除外

两个成员函数，名字和参数表都一样，但是一个是const，另一个不是，算重载

class CTest {
private:
	int n;
public:
	CTest() { n = 1; }
	int test() const { return n; }
	int test() { return 2 * n; }
};

int main()
{
	const CTest objTest1;
	CTest objTest2;
	cout << objTest1.test() << objTest2.test() << endl;
	return 0;
}

常引用：引用前面可以加const关键字，成为常引用。不能通过常引用，修改其引用的变量

在函数中用对象的常引用作为参数，函数中能确保不会无意修改其值

Week 04 运算符重载

Week 05 继承与派生

Week 06 多态与虚函数

Week 07 输入输出,文件操作和模板

Week 08 标准模板库STL (1)

Week 09 标准模板库STL (2)

Week 10 枚举算法

Week 11 递归算法

Week 12 动态规划算法

Week 13 深度优先搜索算法