C++难重点/易混淆点

最新推荐文章于 2022-05-25 21:34:44 发布

一苇_渡江

最新推荐文章于 2022-05-25 21:34:44 发布

阅读量185

点赞数

12.基类／派生类同名成员与protected关键字

1.类成员的可访问范围

关键字private：指定私有成员，只能在成员函数内被访问；

关键字public：指定公有成员，可以在任何地方被访问；

关键字protected：指定保护成员。

class classname{
    private:
        私有属性和函数    //缺省为私有成员；
    public：
        公有属性和函数
    protected：
        保护属性和函数    

}

类的成员函数内部可以访问：当前对象的全部属性、函数；同类其他对象的全部属性、函数。

类的成员函数以外的地方可以访问：只能访问该类对象的公有成员。

接口函数作为连接类外对类内私有或者保护变量的访问，接口函数其实是公有成员的函数。

class Cemployee//代码有问题
{
private:
	char sname[30];
public:
	int salary;
	void setname(char &name);
	void getname(char &name);
	void aversalary(Cemployee e1, Cemployee e2);

};
void Cemployee::setname(char &name) { strcpy(sname, name); }
void Cemployee::getname(char &name) { strcpy(name, sname); }
void Cemployee::aversalary(Cemployee e1, Cemployee e2) { salary = (e1.salary + e2.salary) / 2; }

int main()
{
	Cemployee e;
	strcpy(e.sname, "zhangjiawei");//编译错误，不能访问私有成员
	char s = "zhang";
	e.setname(s);   //ok
	e.salary = 5000;//ok
	return 0;
｝

设置私有成员变量的目的是强制要求，通过成员函数访问，可以把私有成员隐藏。

2.构造函数

构造函数名字与类名相同，可以有参数，不能有返回值，（void）也不行。

作用是对对象进行初始化，默认构造函数不作任何操作。

对象生成时，构造函数自动被调用。

一个类可以有多个构造函数。使用参数区分。

class Complex
{
	private:
		double real,img;
	public:
		Complex(double r, double i=0);
};
Complex::Complex(double r, double i) { real = r; img = i; }

Complex c1(2);               //ok ,一个参数2，第二个是缺省参数
Complex c2(3,4),c3(5,6);     //ok
Complex *p= new Complex(4,5);//ok

class CSample
{
	private:
		int x;
	public:
		CSample() { cout << "Construct1 called" << endl; }
		CSample(int n) { x = n; cout << "Construct2 called" << endl;}
};

int main()
{

	CSample array1[2];
	CSample array2[2] = {3,4};
	CSample array3[2] = {3};
	CSample *array4=new CSample[2];
	delete []array4;
	return 0;
}

输出：
"Construct1 called"
"Construct1 called"

"Construct2 called"
"Construct2 called"

"Construct2 called"
"Construct1 called"

"Construct1 called"
"Construct1 called"

class Test 
{
	public:
		Test(int n) { cout << "Test1" << endl << endl; }
		Test(int n,int m ) { cout << "Test2" << endl << endl; }
		Test() { cout << "Test3" << endl << endl; }
};

int main() 
{

	Test array1[3] = { 1,{2,3} };

	Test array2[3] = { 1,(2,3) };

	//Test *array3[3] = {new Test(1),new Test(3,4)};//系统会崩，第三个只是指针没有指向谁

	//Test *array4 = { Test(1) };//报错

	//Test *array5 = { &Test(1,2) };
	//delete []array3;

	system("pause");
	return 0;
}

输出：
Test1

Test2

Test3

Test1

Test1

Test3

请按任意键继续. . .

3.复制构造函数

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

形如X::X(X &)和X::X(const X & )，二者选一，后者能以常量对象作为参数。

如果没有定义复制构造函数，默认生成。

class Test 
{
	public:
		int a, b;
		Test() {   }
		Test(Test & c) { a = c.a; b = c.b; cout << "copyconstructfun" << endl; }
};//自定义构造函数，上面的c之前面必须加引用符号，不然编译报错

int main() 
{
	Test c1;
	Test c2(c1);//等价于Test c2=c1;这是初始化语句，不是赋值语句
                    //去掉Test则时赋值语句，当然不会调用赋值构造函数，已经生成了
}

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

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

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

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

class Test //2.
{
	public:
		Test() {   }
		Test(Test & c) { cout << "copyconstructfun" << endl; }
};
void func(Test a){}
int main() 
{
	Test c1;
	func(c1);//此时c1的值没有传给c，因为自定义的复制构造函数里没有写相应的程序，注意
}

4.类型转换构造函数

目的：实现类型的自动转换

特点：只有一个参数；不是复制构造函数

编译系统会自动调用，转换构造函数，建立一个临时对象/临时变量

5.析构函数（Destructor）

成员函数的一种；名字与类名相同；在前面加~，没有参数和返回值；

一个类最多只有一个析构函数，对象生命周期结束时调用。

自动生成的缺省析构函数不涉及释放用户申请的内存释放清理工作。

6.静态成员变量和静态成员函数

静态成员：在定义前加了static关键字的成员

普通成员变量每个对象一份，静态成员变量一共就一份，为所有对象共享即影响所以该类的对象的这个变量的值。（静态变量时放在全局区的）

普通成员函数必须具体作用某个对象，而静态成员函数并不具体作用与某个对象。

因此静态成员不需要通过对象就能访问。

静态成员变量本质上时全局变量，对象不存在类的静态成员变量也存在。

静态成员函数本质上是全局函数。

目的是方便维护和理解。显示该变量和该类的关系。

有些CRectangle类会通过复制构造函数，生成对象，而那个不会修改这两个全局变量，导致总数不一致。

临时对象也会产生同样的问题。

7.成员对象和封闭类

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

包含成员对象的类叫封闭类（enclosing）。

初始化列表初始化的方式。

8.友元函数

9.this指针

C++程序到C程序的翻译

普通的成员函数比写的成员函数多一个参数就是this指针。

10.继承和派生

把A作为一个基类，把B作为一个派生类（子类）。

派生类是通过对基类进行修改和扩充得到的，修改举例是定义和基类同样名称的成员函数；在派生类中可以扩充新的成员函数和成员变量。

派生类拥有基类的全部成员函数和成员变量。在派生类的各个成员函数中，不能访问基类的private成员。

11.继承关系和复合关系

基类A与派生类B之间的继承关系，一个B对象也是一个A对象。

复合关系：类A有成员变量ｋ，ｋ是类B的对象，则类A和类B有复合关系。

上述错误使用，循环定义。编译算不出内存体积。

上述错误。