程序设计基础II学习笔记

最新推荐文章于 2024-02-01 21:48:07 发布

hesorchen

最新推荐文章于 2024-02-01 21:48:07 发布

阅读量6.9k

点赞数 1

分类专栏： # C++

本文链接：https://blog.csdn.net/hesorchen/article/details/104947974

版权

C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

第一章面向对象程序设计概述

`面向对象的语言`：

是高级语言。
将客观事物看做具有属性和行为的对象。
通过抽象找出同一类对象的共同属性和行为，形成类。
通过类的继承和多态实现代码的重用
使得代码具有独立性、模块性。利于维护和修改。

`类`：钟表。（本质特征：都是看时间）

`对象（类的实例）`：某块特定的钟表。（颜色、形状等可能不一样）

`类`：分类的主要依据：抽象。例如：石头、汽车、树木等都是人们长期的生产生活中抽象出来的概念。

`类与对象的关系`：犹如模具与铸件的关系，一个属于某类的对象称为该类的一个示例。

`封装`：尽可能简化内部细节。对外形成一个边界，只保留有限的对外接口使之可以与外部发生反应。例如：sort函数就是一个封装好的函数，直接输入地址就可以对数组进行排序。

`继承`：特殊类拥有一般类的全部属性与服务，我们称为特殊类对一般类的继承。例如：轮船是一般类，客船是特殊类。（a是一般类，如果b有a全部属性特点，在此基础上，b还有特殊的属性，那么b就是特殊类。）

`源程序`：还没翻译的代码。（机器无法识别）

`目标程序`：源程序经过翻译生成的程序，可以直接执行。

`翻译程序`：

汇编程序：将汇编语言写的源程序翻译成目标程序。（高级语言用不到）
编译程序：将高级语言写的源程序翻译成目标程序。（C、C++）
解释程序：与编译程序的不同点：编译程序一次性将汇编程序翻译完，解释程序翻译一句、执行一句，反复进行。（JAVA、BASIC）

`程序的开发过程`：（C++为例）

1.编辑：将源程序输入到计算机中，生成后缀为cpp的磁盘文件。
2.编译：将程序的源代码转换为机器语言代码。
3.连接：将多个源程序文件以及库中的某些文件连接在一起，生成一个后缀为exe的可执行文件。
4.运行调试。

第二章面向对象程序设计基础

`cin和cout基本输入和输出`：getline(cin，str)：输入带空格字符串。

`常变量的定义`：const 变量类型变量名=x（所定义的变量为常量）

`引用与常引用`：（对一块地址重复命名）

    int n = 10;
    int &a = n;       //引用
    const int &b = n; //常引用
    cout << a << ' ' << b << endl;

`内联函数`：系统直接将调用内联函数的地方用等价的语句替换，减少运行环境的保存和恢复时间。（在函数名前面加上inline即是内联函数，但是内联函数只适合小功能的函数，例如一个计算公式等）

`带缺省值的函数`：预先给定形参值，如果不给定实参值，则采用形参值。

在这里插入图片描述

`函数重载`：多个参数数量或参数类型不同的函数函数名相同

`动态内存分配`（注意：返回的是分配的空间的首地址）

单个元素的内存分配：

   int *p, *q;
   p = new int(3);//初始化该空间的值为3
   q = new int;
   delete[] p;
   delete[] q;

多个元素的内存分配：

    int *p, *q;
    p = new int[10]; //分配10个int型的元素，把该内存的首地址给p
    q = new int;
    delete[] p;
    delete[] q;

`动态内存的释放`：delete

    int *p, *q;
    p = new int[10];
    q = new int;
    delete[] p; //多个元素的动态内存释放
    delete q;   //单个元素的动态内存释放

第三章类和对象（一）

c++面对对象程序设计，也使用了类和对象的概念，并通过下面的方法来模拟对象的状态和行为：

1.对象的状态通过对象的属性数据来描述。
2.对象的行为：定义一个函数集，通过调用对应函数表示对象完成一个行为。

`类`：由成员变量（数据成员）和成员函数组成

`对象的定义`:类名对象名（形如int a、double a）。

`对象的访问`:

对象名.成员变量名
指向对象的指针名->成员变量名
对象名.成员函数名
指向对象的指针名->成员函数名

代码示例：

	class student
	{
	public:
	    int score;
	    string name;
	    void change_score(int a)
	    {
	        score = a;
	    }
	    void change_name(string a)
	    {
	        name = a;
	    }
	};
	int main()
	{
	    student a;
	    a.change_score(100);
	    a.change_name("hesor");
	    cout << a.name << ' ' << a.score << endl;
	    return 0;
	}
/*
Output:
hesor 100
*/

`构造函数`：主要用来初始化对象的数据成员，构造函数可以重载。构造函数没有函数返回类型，且函数名与类名相同。

`代码示例`：

class student
{
public:
    int score;
    string name;
    student()
    {
        score = 10;
        name = "orz";
    }
    student(int s, string n)
    {
        score = s;
        name = n;
    }

    void change_score(int a)
    {
        score = a;
    }
    void change_name(string a)
    {
        name = a;
    }
};
int main()
{
    //调用无参构造函数 注意:不是student a()
    student a;
    student b(100, "hesor");
    cout << a.name << ' ' << a.score << endl;
    cout << b.name << ' ' << b.score << endl;
    return 0;
}
/*
Output:
orz 10
hesor 100
*/

`类的访问控制`：

public：公有成员，在程序的任何地方都可以访问。一般作为类与外界的接口。
private：私有成员，只能被该类的成员函数或该类的友元访问。
protect：保护成员，与私有成员差不多，主要在继承方面有区别，（派生类可以访问基类的保护成员，但是不能访问基类的私有成员）。

`析构函数`：析构函数和构造函数类似，不过构造函数是在创建对象的时候自动调用，而析构函数是在销毁对象的时候程序自动调用。但是析构函数需在函数名前加上~，并且析构函数没有参数（因此析构函数不能重载）。

`拷贝构造函数`：一种特殊的构造函数，用一个已存在对象来初始化正在创建的新对象。

`类的继承`：A类继承B类，B叫做基类，A叫做派生类（也叫做父类与子类）。

class student : public person
{
};

上面就是以persoon类为基类，student为派生类的公有继承方式，student类自动继承person类中的所有属性和方法（可以根据需要在派生类中添加属性和方法）。

`派生类构造函数`：

class person
{
public:
    string name;
    int high;
    person(string a, int h)
    {
        name = a;
        high = h;
    }
};
class student : public person
{
public:
    int score;
    // student(int a)  //1
    // 如果采用 1 这种派生类的构造函数，那么基类默认使用无参构造函数初始化从基类继承的成员
    student(int a) : person("hesor", 170) //派生类构造函数
    {
        score = a;
    }
};
main()
{
    student a(100);
    cout << a.name << ' ' << a.score << ' ' << a.high << endl;
    return 0;
}
/*
Output:
hesor 100 170
*/

`派生类构造函数`：与基类构造函数一样，但是需要注意一点：派生类析构函数调用的时候基类中的析构函数也会调用！

class person
{
public:
    string name;
    int high;
    person(string a, int h)
    {
        name = a;
        high = h;
    }
    ~person()
    {
        cout << "基类 end... ..." << endl;
    }
};
class student : public person
{
public:
    int score;
    // student(int a)  //1
    // 如果采用 1 这种派生类的构造函数，那么基类默认使用无参构造函数初始化基类成员变量
    student(int a) : person("hesor", 170) //派生类构造函数
    {
        score = a;
    }
    ~student()
    {
        cout << "派生类 end... ..." << endl;
    }
};
main()
{
    student a(100);
    cout << a.name << ' ' << a.score << ' ' << a.high << endl;
    return 0;
}
/*
Output:
hesor 100 170
派生类 end... ...
基类 end... ...
*/

`函数重定义`：派生类对基类中继承过来的函数进行重新定义（要求函数返回值、参数个数、参数类型完全一致）。

class person
{
public:
    void f()
    {
        cout << "基类" << endl;
    }
};
class student : public person
{
public:
    void f()
    {
        cout << "派生类" << endl;
    }
};
main()
{
    student a;
    person b;
    a.f();
    b.f();
    return 0;
}
/*
Output:
派生类
基类
*/

`多重继承下的派生类的定义`：

class student
{
public:
    void f_student()
    {
        cout << "我是学生" << endl;
    }
};
class teacher
{
public:
    void f_teacher()
    {
        cout << "我是老师" << endl;
    }
};
class student_teacher : public student, public teacher
{
};
main()
{
    student_teacher a;
    a.f_student();
    a.f_teacher();
    return 0;
}
/*
Output:
我是学生
我是老师
*/

注意，在继承时，总是先调用基类的构造函数再调用派生类的构造函数，多重继承时，按照继承基类的顺序调用构造函数。析构函数的调用顺序恰好与构造函数的调用规律相反。

`多重继承中的二义性问题`：由于多重继承有多个基类，基类的属性名和方法名可能重复，所以派生类中会产生二义性问题。例如下图，若A有成员变量name，BC继承了A之后都会有变量 name，然后 D又多重继承了BC，那么D就会有两个name变量，调用的时候就会产生二义性。

`解决方法`：

通过作用域运算符指定要调用哪个基类的属性和方法：

class person
{
public:
    int NUM = 123456;
};
class student : public person
{
};
class teacher : public person
{
};
class student_teacher : public student, public teacher
{
};
main()
{
    student_teacher a;
    cout << a.teacher::NUM;
    return 0;
}
/*
Output:
123456
*/

虚拟继承：加入virtual关键字，将图中的A类定义为虚基类，虚基类的成员在类的继承关系中只会被继承一次。

class person
{
public:
    int NUM = 123456;
};
class student : virtual public person
{
};
class teacher : virtual public person
{
};
class student_teacher : public student, public teacher
{
};
main()
{
    student_teacher a;
    cout << a.NUM;
    return 0;
}
/*
Output:
123456
*/

更新ing… …

hesorchen

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
2
评论
程序设计基础II学习笔记

第一章面向对象程序设计概述面向对象的语言：是高级语言。将客观事物看做具有属性和行为的对象。通过抽象找出同一类对象的共同属性和行为，形成类。通过类的继承和多态实现代码的重用使得代码具有独立性、模块性。利于维护和修改。对象：钟表。（本质特征：都是看时间）对象的实例：某块特定的钟表。（颜色、形状等可能不一样）类：分类的主要依据：抽象。例如：石头、汽...
复制链接

扫一扫