学习C++(二、类与对象)

1、什么是面向对象

在了解类与对象时,首先要明白什么是“面向对象”:(重点是:封装、继承、多态)
面向对象:对人不对事,变中求不变,更加灵活;
面向过程:对事不对人,一个事一个对象,死板不够灵活;
{//例: 五子棋
面向过程(按步骤走) //1开始游戏 ->2黑子先走-> 3绘制画面 -> 4判断输赢 -> 5轮到白子 -> 6 绘制画面 -> 7判断输赢,8返回步骤2,9 输出最后结果
面向对象 //找出对象: 棋手 棋盘 裁判
//对象间交互演化万千变化: 黑方走哪个位置,白方如何应对 - > 变中求不变( 事是人做的,事可变化万千,但人不变)
}

2、类的定义

既然本文的题目为“类与对象”,咱们先认识一下什么是类、对象。
类:是一个抽象概念,是一个想法,规划;
对象:是一个能够“看得见、摸得着的实体”,是类的具象化,也称为对象的实例化。
定义类的格式:

class 类名
{
成员访问控制符;			//描述成员访问权限:private、public、protected
数据成员;			//描述类的属性和特征
成员访问控制符;
成员函数;			//描述类的行为,也成类的方法,可在类内/外定义;
};

其中:
private:修饰的私有成员,只能在类的成员函数或类的友元韩式中访问,不能在类的外部访问;
public : 公有成员,可以在类的外部直接访问;
protected:受保护的成员, 权限与private私有成员一样,区别在于受保护的成员可以在该类的派生类中访问(子类可访问protected修饰的成员)。

//类 对象

#include <iostream>
#include <string>


using namespace std;

class Student
{
public:
    int GetAge() const;
    double AvgScore();
    void PrintAdd();
    void PrintSizeofMem()
    {
        cout<< "sizeof(strName):"<<sizeof(strName)<<",sizeof(nAge):"<<sizeof(nAge)
            <<",sizeof(arrScore):"<<sizeof(arrScore)<<endl;
    }
private:
    string strName;
    int nAge;
    double arrScore[4];
};

int Student :: GetAge() const   //类方法(函数)
{
    return nAge;
}
double Student ::AvgScore()
{
    double sumScore = 0;
    for(int i = 0;i < 4;i++){
        sumScore += arrScore[i];
    }
    return sumScore/4;
}

void Student::PrintAdd()
{
    cout << "Address(strName):"<< &strName <<",Address(nAge):" <<&nAge <<
            ", Address(arrScore):" << arrScore <<endl;
    cout << "Address(GetAge):"<< (void*)(&GetAge) <<",Address(AgeScore):" <<(void*)(&AvgScore) <<endl;
}

int main()
{
    Student s1,s2;			//类的实例化即定义对象s1 s2
    s1.PrintAdd();			//引用类成员
    s2.PrintAdd();
    s1.PrintSizeofMem();
    s2.PrintSizeofMem();
    cout<<"sizeof(s1):"<<sizeof(s1)<<",sizeof(s2):"<<sizeof(s2)<<endl;
    return 0;
}

注:
(1)编译器会为每个对象的数据成员分配独立的内存空间,但是所有成员的代码之占内存中一块空间;
(2)计算对象占用内存空间的大小时,是所以数据成员占用内存总和,不包括代码占用空间,但是为了实现字节对齐,对象占用空间大小会与上述空间大小有出入。

3、对象的创建与销毁

上面以经描述过,对象就是类的实例化,在定义一个类后,想要使这个类有具体意义,就必须创建相应的对象:
创建对象也称为声明对象或实例化对象,具体格式是:

类名 对象列表; //如上例中: Student s1 , s2;

相应的,在创建完对象后,访问对象成员的方法为:

对象名.数据成员名;
对象名.成员函数名();

1.构造函数:对象创建时自动调用—>分配资源
(1)构造函数是一类特殊的成员函数,在对象创建时自动调用,以实例化一个对象,如果程序员没有显示的提高一个构造函数,编译器会自动提供一个默认的构造函数。
构造函数作用------->数据成员初始化;

//默认构造函数
#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
    Student();  //声明默认构造函数
    int GetAge() const;
    double AvgScore();
    void PrintAdd();
    void PrintSizeofMem()
    {
        cout<< "sizeof(strName):"<<sizeof(strName)<<",sizeof(nAge):"<<sizeof(nAge)
            <<",sizeof(arrScore):"<<sizeof(arrScore)<<endl;
    }
private:
    string strName;
    int nAge;
    double arrScore[4];
};

Student::Student()          //默认构造函数实现
{
    cout << "use Constructor" <<endl;
}
int Student :: GetAge() const
{
    return nAge;
}
double Student ::AvgScore()
{
    double sumScore = 0;
    for(int i = 0;i < 4;i++){
        sumScore += arrScore[i];
    }
    return sumScore/4;
}

void Student::PrintAdd()
{
    cout << "Address(strName):"<< &strName <<",Address(nAge):" <<&nAge <<
            ", Address(arrScore):" << arrScore <<endl;
    cout << "Address(GetAge):"<< (void*)(&GetAge) <<",Address(AgeScore):" <<(void*)(&AvgScore) <<endl;
}

int main()
{
    Student s1,s2;
    s1.PrintAdd();
    s2.PrintAdd();
    s1.PrintSizeofMem();
    s2.PrintSizeofMem();
    cout<<"sizeof(s1):"<<sizeof(s1)<<",sizeof(s2):"<<sizeof(s2)<<endl;
    return 0;
}
#endif


#if 0
//自定义带参数的构造函数
#include<iostream>
#include<string>

using namespace std;

class Student
{
public:
    Student(const string&, int); //声明构造函数,不用重复定义参数名,
                                 //等价与Student(const string& name,int age);
    int GetAge() const {return nAge;};
    void SetAge(int n) {nAge = n;};
private:
    string strName;
    int nAge;
    };
Student :: Student(const string& name,int age)
{
    strName = name;           //数据成员初始化
    nAge = age;               //除此种方式外还可以用参数初始化表的形式初始化数据成员
}
/*
用参数初始化表的形式初始化数据成员
Student :: Student(const string& name,int age):strName(name),nAge(age)
{

}
*/
int main()
{
    Student s1("Jason",18);
    cout << "s1年龄:"<<s1.GetAge() <<endl;
    return 0;
}
#endif

(2)拷贝构造函数
当使用一个对象为另一个对赋值时(如同使用变量b为变量a赋值),编译器将调用拷贝构造函数。

int b = 3;
int a = b; 	//使用变量b为变量a赋值,也可写成int a{b};
Student s1;
Student s2{s1};	//Student s2 = s1;  此时便会调用拷贝构造函数

构造函数的语法同样适用于拷贝构造函数,但是:拷贝构造函数的形参必须是类对象的引用,最好是常引用。

//例
Student ::Student(const Student & s);
拷贝构造函数触发时机:案例
1、用对象初始化另一个对象Student s1; //声明对象s1
1、—Student s2(s1);//初始化对象s2同Student s2=s1;
2、函数调用时,用对象作为实参传递给函数形参Student s1;
2、—AvgScore(s1); //函数AvgScore的原型double AvgScore(Student);以类对象为形参
3、函数返回值为类对象,创建临时对象作为返回值时Student LargerAge(Student s);//参数是Student类对象,函数返回值时Student类对象,对象s1调用函数LargerAge时的语句为: s3 = s1.LargerAge(s2);

注:默认构造函数:函数体为空,但是默认拷贝构造函数是进行成员变量之间的拷贝。

//了解深拷贝浅拷贝前先了解下面程序,看发生了什么
#include <iostream>
#include  <string>
using namespace std;
class Student
{
public:
    Student(const string = "",int = 16,double = 0,double = 0,double = 0);
    ~Student();
    double AvgScore();
private:
    string strName;
    int Age;
    double *pScore;
};

Student::Student(const string& name,int age,double scrEng,double scrMath,double scrCpp )
{
    strName = name;
    pScore = new double[3];
    pScore[0] = scrEng;
    pScore[1] = scrMath;
    pScore[2] = scrCpp;

}
Student::~Student()
{
    cout << "Student destructor is callde."<<endl;
    delete [] pScore;
    cout<<"Student destructor is finished,return..."<<endl;

}
double Student::AvgScore()
{
    return (pScore[0]+pScore[1]+pScore[2]) / 3;
}
int main()
{
    Student s1("Jason",18,75,82,79);
    cout<<"s1的平均成绩:"<<s1.AvgScore()<<endl;
    Student s2(s1);
    cout<<"s2的平均成绩:"<<s2.AvgScore()<<endl;
    return 0;
}
//以上程序出现的问题是:delete运算符重复释放已经被释放过的内存空间,导致程序出现崩溃性错误!
//解决方法:重新定义拷贝构造函数,实现指针的深度复制(深拷贝)。

注:在上面的程序中Lin38行 Student s2(s1);在创建对象s2时,使用对象s1为其初始化,此时恒旭会调用默认拷贝构造函数(进行成员变量之间的拷贝)实例化对象,拷贝构造函数中实现的三条赋值语句如下:

s2.strName = s1.strName;
s2.nAge = s1.nAge;
s2.pScore = s1.pScore;

其中,s2.pScore与s1.pScore指向同一块内存空间,在程序执行完成时,首先调用析构函数撤销s2的空间,再撤销s1的空间,但因为两块空间为同一块,重复撤销已经被撤销的空间,导致程序出现崩溃性错误。
解决以上问题的方法:重新定义拷贝构造函数,实现指针的深度复制。(深拷贝)
可添加以下代码:

Student::Student(const Student &s)
{
    strName = s.name;
    nAge = s.age;
    pScore = new double[3];
    pScore[0] = s.scrEng;
    pScore[1] = s.scrMath;
    pScore[2] = s.scrCpp;
}

2.析构函数:对象销毁时调用------>释放资源
在声明一个对象时,编译器会自动调用构造函数实例化该对象,当该对象的声明周期结合素时,编译器又会自动调用析构函数,撤销该对象。析构函数的定义格式是:
(1)在构造函数名前加 ‘~’;
(2)析构函数同样没有返回值类型声明,也无return语句;
(3)析构函数没有参数,不能重载;
例:
~ Student();
向上面这种默认的析构函数不执行任何操作,但是如果在对象消亡之前希望能够清理资源、计算当前活跃对象数目等操作,可以显示的定义析构函数,比如在对象执行中使用new申请了一块空间,执行完后需要回收该空间,delete就可以在析构函数内执行。
注意:在继承关系的程序中,需要先析构儿子,再析构父亲;

栈溢出原因解决方法
(1)函数层次调用过深,每调用一次,函数的参数、局部变量等信息压一次栈;(2)局部变量体积太大;(1)增加栈内存数目;(2)使用堆内存(比如:把数组定义为指针,然后用new申请内存;把局部变量改为全局变量;在定义前加static编变成静态变量)
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值