发表于 更新于 分类于
本文字数： 1.2k 阅读时长 ≈ 1 分钟

C++友元

Guderian出品

本文整理自《北京大学公开课：C++面向对象程序设计》

友元很简单，在某种程度上算作是C++设计者对C使用者的妥协。友元分为友元函数和友元类两种。

友元函数

一个类的友元函数可以访问该类的私有成员，友元函数不是这个类的成员函数，可以是一个普通的全局函数或其他类的成员函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class CCar;	//提前声明CCar是一个类，以便后面的CDriver类使用
class CDriver
{
    public:
    	void ModifyCar(CCar *pCar);
};
class CCar
{
    private:
    	int price;
    friend int MostExpensiveCar(CCar cars[], int total);	//声明友元
    friend void CDriver::ModifyCar(CCar *pCar)	//声明友元
};
void CDriver::ModifyCar(CCar *pCar)
{
    pCar->price += 1000;	//汽车改装后价值增加
}
int MostExpensiveCar(CCar cars[], int total)
{
    int tmpMax = -1;
    
    for(int i = 0; i < total; ++i)
    	if(cars[i].price > tmpMax)
            tmpMax = cars[i].price;
    
    return tmpMax;        
}

可以将一个类的成员函数（包括构造、析构函数）说明为另一个类的友元

1
2
3
4
5
6
7
8
9
class B
{
    public:
    	void function();
};
class A
{
    friend void B::function();
};
阅读全文 »

发表于 更新于 分类于
本文字数： 1.8k 阅读时长 ≈ 2 分钟

C++常量对象、常量成员函数和常引用

图：广州塔

Guderian出品

本文整理自《北京大学公开课：C++面向对象程序设计》

常量对象

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

1
2
3
4
5
6
7
8
9
class CDemo
{
    private:
    	int vale;
   	public:
    	void SetValue()	{}
};

const Demo obj;	//常量对象

常量成员函数

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

常量成员函数执行期间不应该修改其所作用的对象。因此，在常量成员函数中不能修改成员变量的值（静态成员变量除外），也不能调用同类的非常量成员函数（静态成员函数除外）。

非常亮成员函数在执行的过程中是有可能修改掉常量成员函数中的值的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Sample
{
    public:
    	int value;
    	void GetValue() const;
    	void func()	{};
    	Sample() {}
};
void Sample::GetValue() const
{
    value = 0;
    //wrong,不能修改成员变量的值
    func();
    //wrong,不能调用同类的非常量成员函数
}

int main()
{
    const Sample o;
    o.value = 100;	//err,不能修改成员变量的值
    o.func();		//err,不能调用同类的非常量成员函数
    o.GetValue();	//ok,可以执行常量成员函数
    
    return 0;
}

常量成员函数的重载

两个成员函数，名字和参数表都一样，但是一个是const，一个不是，算重载，而不是重复定义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class CTest
{
    private:
    	int n;
    public:
    	CTest()	{ n = 1 ;}
    	int GetValue() const { return n; }
    	int GetValue() { return 2 * n; }
    	//这两个GetValue()函数是重载关系，而不是重复定义
};

int main()
{
    const CTest objTest1;
    CTest objTest2;
    
    cout << objTest1.GetValue() << ", " << objTest2.GetValue();
    //objTest1是常量对象，调用的是GetValue() const
    //objTest2是非常量对象，调用的是GetValue()
    
    return 0;
}

常引用

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

1
2
3
const int &r = n;
r = 5;	//error
n = 4;	//OK
阅读全文 »

发表于 更新于 分类于
本文字数： 2.9k 阅读时长 ≈ 3 分钟

C++复制构造函数

图：广州天河CBD

Guderian出品

本文整理自《北京大学公开课：C++面向对象程序设计》

基本概念

  • 只有一个参数，即对同类对象的引用
  • 形如X::X(X &)或X::X(const X &)，二者选一，后者能以常量对象作为参数
  • 如果没有定义复制构造函数，那么编译器生成默认的复制构造函数。默认的复制构造函数完成复制功能

构造函数与复制构造函数的异同

  • 构造函数（或称无参构造函数）不一定存在，你不写构造函数，编译器就只会帮你生成一个什么也不做的无参构造函数
  • 复制构造函数一定存在，你不写复制构造函数，编译器也会帮你写好一个具有复制功能的复制构造函数
1
2
3
4
5
6
7
8
class Complex
{
    private:
    	douebl real, imag;
};

Complex c1;		//调用缺省的构造函数
Complex c2(c1);	//调用缺省的复制构造函数，将c2初始化成和c1一样
  • 如果定义了自己的复制构造函数，则默认的复制构造函数不存在
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Complex
{
    public:
    	double real, imag;
    	Complex()	{}
    	Complex(const Complex &c)
        {
            real = c.real;
            imag = c.imag;
            cout << "Copy constructor called";
        }
};

Complex c1;
Complex c2(c1);
//调用自己定义过的复制构造函数，输出Copy constructor called

特别强调1

注意：不允许有形如X::X(X)的复制构造函数，参数一定是引用，不能是对象

1
2
3
4
5
6
7
8
class CSample
{
    CSample(CSample c)
    {
        //错，不允许出现这样的复制构造函数
        //这样写的话，下面的内容要么变成了构造函数，要么语法是错误的
    }
};

复制构造函数起作用的三种情况

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

1
2
Complex c2(c1);
Complex c2 = c1; 	//初始化语句，非赋值语句，与上面写法是等价的

（2）当某函数有一个参数是类A的对象时

那么该函数被调用时，类A的复制构造函数将被调用。C++规则：形参是实参的拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class A
{
    public:
    	A()	{};
    	A(A &a)
        {
        	cout << "Copy constructor called" << endl;    
		}
};

void Func(A a1)	{}

int main()
{
    A a2;
    Func(a2);
    
    retrun 0;
}
//输出：
Copy constructor called

（3）当函数的返回值是类A的对象时

那么在函数返回时，A的复制构造函数被调用，作用是初始化作为返回值的类A对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class A
{
    public:
    	int v;
    A(int n)	{v = n};
    A(const A &a)
    {
        v = a.v;
        cout << "Copy constructor called" << endl;
	}
};

A.Func()
{
    A b(4);
    return b;
}

int main()
{
    cout << Func().v << endl;
    //此处Func()的返回值没有名字，是一个复制构造函数初始化的对象
    
    return 0;
}

//输出：
Copy constructor called
4
阅读全文 »

发表于 更新于 分类于
本文字数： 3k 阅读时长 ≈ 3 分钟

C++ 构造参数

图：深圳福田CBD

Guderian出品

本文整理自《北京大学公开课：C++面向对象程序设计》

构造函数的性质

  • 构造参数是成员函数的一种
  • 名字与类名相同，可以由参数，不能有返回值（void也不行）
  • 作用是对对象进行初始化，如给成员变量赋初值
  • 如果定义类的时候没写构造函数，则编译器生成一个默认的无参数的构造函数
  • 默认构造函数无参数，不进行任何操作
  • 如果定义了构造函数，则编译器不生成默认的无参数的构造函数
  • 对象生成时构造函数被自动调用。对象一旦生成，就再也不能在其上执行构造函数
  • 一个类可以有多个构造函数

注：如果只定义了带参构造函数，在定义对象时必须声明参数

为什么需要构造函数：

  • 不用专门写初始化函数，也不用担心忘记
  • 有时对象没有被初始化，会导致程序出错

构造函数的使用

一个类可以有一个构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Circle
{
    private:
    	double radius, xLoc, yLoc;
    public:
    	Circle(double r ,double x = 0, y = 0)
};
Circle::Circle(double r, double x, double y)
{
    radius = r, xLoc = x, yLoc = y;
}

//Wrong samples
Circle c1;	//error,缺少构造函数的参数
Circle *pc = new Circle;	//error，没有参数

//Correct samples
Circle c1(2);	//OK
Circle c1(2, 4, 4);	//OK
Circle *pc = new Circle(3, 4);	//also OK

一个类可以有多个构造函数

只要不同的构造函数的参数个数和参数类型不同，这些构造函数就会构成重载的关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Circle
{
    private:
    	double radius, xLoc, yLoc;
    public:
    	Circle(double r ,double x = 0, y = 0)
        Circle(double r);
    	Circle(Circle c1, Circle c2)
};
Circle::Circle(double r, double x, double y)
{
    radius = r, xLoc = x, yLoc = y;
}
Circle::Circle(double r)
{
    radius = r;
}
Circle::Circle(Circle c1, Circle c2)
{
    radius = c1.radius + c2.radius;
    xLoc   = c1.xLOc   + c2.xLoc;
    yLoc   = c1.yLOc   + c2.yLoc;
}

//Samples
Circle c1(3), c2(1, 0), c3(c1, c2);
阅读全文 »

发表于 更新于 分类于
本文字数： 1.5k 阅读时长 ≈ 1 分钟

不定积分公式

Guderian出品


$(1)\int0 \mathrm{dx} = C$

$(2)\int1\mathrm{dx}=x+C$

$(3)\int x^\mu \mathrm{dx}=\frac1{\mu+1}x^{\mu+1}+C(\mu \ne -1)$

$(4)\int\frac1{x}\mathrm{dx}=\ln|x|+C$

$(5)\int a^x \mathrm{dx}=\frac{a^x}{\ln a}+C$

$(6)\int e^x \mathrm{dx}=e^x+C$

$(7)\int \sin x \mathrm{dx}=-\cos x +C$

$(8)\int \cos x \mathrm{dx}=\sin x +C$

$(9)\int \sec^2 x \mathrm{dx}=\int \frac1{\cos^2 x}\mathrm{dx}=\tan x+C$

$(10)\int \csc^2x\mathrm{dx}=\int \frac1{\sin^2x}\mathrm{dx}=-\cot x +C$

$(11)\int\sec x\tan x\mathrm{dx}=\sec x+C$

$(12)\int \csc x\cot x\mathrm{dx}=-\csc x +C$

$(13)\int \frac{\mathrm{dx}}{\sqrt{1-x^2}}=\arcsin x+C$

$(14)\int \frac{\mathrm{dx}}{1+x^2}=\arctan x+C$

$(15)\int \tan x\mathrm{dx}=-\ln|\cos x|+C$

$(16)\int \cot x \mathrm{dx}=\ln|\sin x|+C$

$(17)\int \sec x \mathrm{dx}=\ln|\sec x+\tan x|+C$

$(18)\int \csc x\mathrm{dx}=\ln|\csc x -\cot x|+C$

$(19)\int \frac{\mathrm{dx}}{x^2+a^2}=\frac1{a}\arctan {\frac{x}{a}}+C$

$(20)\int \frac{\mathrm{dx}}{x^2-a^2}=\frac1{2a}\ln|\frac{x-a}{x+a}|+C$

$(21)\int \frac{\mathrm{dx}}{\sqrt{a^2-x^2}}=\arcsin \frac{x}{a}+C$

$(22)\int \frac{\mathrm{dx}}{\sqrt{x^2\pm a^2}}=\ln|x+\sqrt{x^2\pm a^2}|+C$

$(23)\int \sqrt{a^2-x^2}\mathrm{dx}=\frac{x}{2}\sqrt{a^2-x^2}+\frac{a^2}{2}\arcsin \frac{x}{a}+C$

$(24)\int \sqrt{x^2\pm a^2}\mathrm{dx}=\frac{x}{2}\sqrt{x^2\pm a^2}\pm \frac{a^2}{2}\ln|x+\sqrt{x^2\pm a^2}|+C$

$(25)\int \ln x\mathrm{dx}=x\ln x-x+C$

阅读全文 »