精华内容
下载资源
问答
  • c++类和对象

    千次阅读 2019-01-13 15:26:38
    首先,明白c++和C语言的区别: C语言面向过程,c++面向对象; 面向过程:即我们着力于项目的每个过程... 由于c++面向对象的特点,类和对象就由此产生; :是抽象的一个类别; 对象:是的实例化,相当于现实...

    首先,明白c++和C语言的区别:

    • C语言面向过程,c++面向对象;
    • 面向过程:即我们着力于项目的每个过程动作,实现每一个动作方法,分析出求解问题的步骤,通过函数调用逐步解决问题;
    • 面向对象:即着力于对象,从对象个体出发,看对象的需求,将一件事情拆分成不同的对象,靠对象之间的交互完成;
    • 由于c++面向对象的特点,类和对象就由此产生;
    • 类:是抽象的一个类别;
    • 对象:是类的实例化,相当于现实世界的实体;

    类的实现:

    • 将C语言中的struct进行延伸,c++中的struct可用来实现类;即可在struct内定义变量和函数;
    struct Student
    {
        void SetStudentInfo(const string name, const string gender, int age)
        {
            strcpy(name, name);
            strcpy(gender, gender);
            age = age;
        }
        void PrintStudentInfo()
        {
            cout<<name<<" "<<gender<<" "<<age<<endl;
        }
        string name;
        string gender;
        int age;
    };
    • 在c++中我们常用class来定义类
    class Student
    {
        void SetStudent(const char* name, const char* gender, int age)
        {
            strcpy(_name, name);
            strcpy(_gender, gender);
            _age = age;
        }
        void PrintStudent()
        {
            cout<<_name<<" "<<_gender<<" "<<_age<<endl;
        }
        char _name[20];
        char _gender[3];
        int _age;
    };

    类的访问限定符:

    1.  public修饰的成员在类外可以直接被访问,public修饰的成员函数类内可访问public、protected、private修饰的成员;
    2.  protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的),而类内protected修饰的成员函数不能访问public修饰的成员,private修饰的成员函数不能访问public、protected修饰的成员;
    3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止;
    4. class的默认访问权限为private,struct为public(因为struct要兼容C);
    5. 访问限定符只在编译时有用,当数据映射到内存后,没有任何访问限定符上的区别。

    类的实例化:用类类型创建对象的过程,称为类的实例化

    1.  类只是一个模型一样的东西,限定了类有哪些成员,定义出一个类并没有分配实际的内存空间来存储它;
    2.  一个类可以实例化出多个对象,实例化出的对象 占用实际的物理空间,存储类成员变量;
    3. 类实例化出对象就像现实中使用建筑设计图建造出房子,类就像是设计图,只设计出需要什么东西,但是并没有实体的建筑存在,同样类也只是一个设计,实例化出的对象才能实际存储数据,占用物理空间。

     

     

     

    展开全文
  • C++类和对象数组

    万次阅读 多人点赞 2018-05-14 23:47:15
    C++类和对象数组 【1】对象数组 1:对象数组的定义:类名 数组名[元素个数] Eg: student asa[10];//有10个元素的学生类对象数组 2:对象数组的访问形式:数组名[下标].成员名; Eg: asa[j].print(); 3:对象...

    C++类和对象数组

    1】对象数组

    1:对象数组的定义:类名 数组名[元素个数]

    Eg: student asa[10];//10个元素的学生类对象数组

    2:对象数组的访问形式:数组名[下标].成员名;

    Eg: asa[j].print();

    3:对象数组的初始化:对象数组的初始化通常也是由构造函数来完成的。

    Eg: #include”student.h”

    int main

    {

    student asa[4]={student1,“LiMing,98,student(2,”Bill”,89),student(3,”Chlily”,99),student(4,”Saraea”,96)};

    for(int i=0;i<4;i++)

    asa[i].print();

    return 0;

    }

    2】指向对象的指针

    1:对象指针的用法:定义对象指针的语法和定义其它基本数据类型指针的语法相同。在使用对象指针之前,要把它指向一个已经创建的对象,然后才能访问该对象的成员。在使用对象名来访问对象成员时,要使用点运算符“.。如果要通过指向对象的指针来访问对象的成员,那么必须使用箭头运算符“->

    3this指针

        Eg: class student

    {

        int number;

        char name[15];

        float score;

        void display()

    {

        cout<<”number: ”<<number;

    cout<<”name: <<name;

    cout<<”score: <<score;<<endl;

    }

    };

    1:在成员函数display()中有一个隐藏的指针作为参数,该指针参数使用关键字this命名,它是指向该类对象的指针,成员函数可以通过它来访问该类对象的数据成员。voiddisplay(student *this)//this指针由编译器自动生成。

    2this指针是由C++编译器自动产生的一个隐含指针,编译器将该指针自动插入到类的所有成员函数的参数列表中,成员函数使用该指针来存取对象的数据成员。

    3:内存中只有一份成员函数的备份,而且对象的实例变量和成员函数是分开存放的,egX const *this。当对象调用该函数时,编译器自动将该对象的地址作为实参传递给相应的成员函数的this指针。

    Eg:void date::set(date* constthis,int d,int m,int y)

    {

        this->day=d;

        this->month=m;

        this->year=y;

    }

    注意:this指针由编译器自动生成,程序员不能将this指针的说明写在函数中,否则将出现编译时间错误信息。

    4this指针是系统的一个内部指针,通常以隐式方式使用,但也可以被程序员显式使用,例如,当运算符重载和建立双向链表时,显式使用this指针十分必要。

    4】对象的赋值:如果两个对象属于同一种类类型,换句话说,两个对象是由同一个类声明的,那么我们可以将其中的一个对象的值(属性值)赋给另一个对象。默认情况下,当将一个对象赋值给另一个对象时,第一个对象的数据将被按位复制到第二个对象中。对象的赋值仅仅是使两个对象的值相等,而这两个对象仍然是相互独立的,即修改一个对象的值将不会影响到另一个对象。

    Eg:Rectangle rect1(10,20),rect2(0,0);

        rect2=rect1;

    5】对象作为函数参数:分类:传值调用,传址调用

        1:传值调用:传值调用,传送的是作为实际参数的对象的拷贝而不是实际对象的本身。因此在函数中改变对象的值不会影响作为实际参数对象本身。

        Class Square

    {

            int side;

        public:

           void set(int x) {side=x;}

           void out() {cout<<side<<”\n”;}

    };

    void f(square x)

    {

        x.out();

        x.set(100);

        x.out();

    }

        int main()

    {

        Square s;

        s.set(10);

        f(s);

        s.out();

    return 0;

    }  

        2:传址调用:当函数调用时传递的是作为实际参数的对象的地址,就是传址调用方式。在函数中对作为形式参数的对象的修改实际上就是对作为实际参数的对象的修改。我们既可以使用对象的引用来实现传址调用,也可以用指针来实现。

    使用对象的引用来实现传址调用:

    Class Square

    {

            int side;

        public:

           void set(int x){side=x;}

           void out() {cout<<side<<”\n”;}

    };

    void f(square &x)//对象的引用作为函数的参数

    {

        x.out();

        x.set(100);

        x.out();

    }

        int main()

    {

        Square s;

        s.set(10);

        f(s);

        s.out();

    return 0;

    }

    使用指向对象的指针来实现传址调用的例子

    Class Square

    {

            int side;

        public:

           void set(int x){side=x;}

           void out() {cout<<side<<”\n”;}

    };

    void f(square *x)

    {

        x.out();

        x.set(100);

        x.out();

    }

        int main()

    {

        Square s;

        s.set(10);

        f(&s);

        s.out();

    return 0;

    }

    6】从函数返回对象:当函数返回对象时,函数创建了一个临时对象来保存要返回的值,而函数所返回的对象实际上是这个临时对象。在对象的值被返回之后,临时对象将被销毁。

        Eg:mystring input()

    {

        char instr[80];

        mystring str;

       cin>>instr;

    str.set(instr);

    return str;//返回一个mystring对象

    }

    int main()

    {

        Mystring ob;

        ob=.input();

        ob.print()

        return 0

    }

    7】类的静态成员

    1:静态成员:C中通过在变量定义的前面加static关键字就可以将变量声明为静态变量。采用局部静态变量可以减少全局变量的使用:将全局变量声明为静态的可以降低全局变量的副作用。C++中通过在类的成员函数前面加上static关键字将其成员声明为静态成员,一个类的静态成员既可以是静态数据成员,也可以是静态成员函数。

    1. 静态数据成员

      声明类的静态数据成员的方式是在变量定义的前面加static关键字

      classstudent

      {

        private:

            int num;

            char *name;

            float score;

            static int count;

            static float sum;//类student的静态数据成员的声明

        public:

            ……

      };

      intstudent::count=0;

      floatstudent::sum=0; //静态成员变量应在创建类的对象前定义并进行初始化

      一个类的静态数据成员为该类的所有对象所共有,不管创造了这个类的多少个对象,其静态数据成员在内存中只有一份拷贝。由于只有一个类的静态成员只有一份拷贝,所以我们经常使用“类名::”来访问静态数据成员。例如:counter::count=0;

          静态成员变量的最一般的作用就是对一些共享资源提供存取控制。

      静态成员好处就是减少了全局变量的使用。

      静态成员主要作用就是定义类的各个对象所共用的数据,如统计总数,平均数等。

     2:静态成员函数:在类的成员函数前面加上static关键字说明的函数就是静态成员函数。只使用静态数据成员的函数可以定义为静态成员函数。对静态成员函数的引用使用所属的类名加作用域分辨运算符来限制,即“类名::”。

    Eg: classStudent

    {

        private:

           ……

        public:

    static void init()

    {

                   Student::count=0;

                  Student::sum=0;

    }

    Static float average();

    };

    float student::average()

    {

        cout<<”sum is <<sum<<\tcount is <<count<<endl;

        cout<<”average is”<<sum/count<<endl;

        return sum/count;

    }

    静态成员函数可以在创建该类的任何成员之前处理静态数据成员,这是普通成员函数不能实现的。一般来说,类的静态成员函数是用来访问静态数据成员的,当然可以访问全局变量。静态成员函数不具有this指针。也就是说,静态成员函数不与某个具体的对象相联系,它只属于该类。

    8】类的友元

    1:友元函数:将关键字friend放在函数名的前面就将该函数说明为友元函数。一个类的友元函数是在该类中说明的一个非成员函数,但允许访问该类对象的所有成员。友元函数可以访问类的私有成员,节省了调用成员函数的开销,从而提高了程序的运行效率。如果需要一个函数同时访问多个类,则它可以定义为多个类的友元函数。1)使用友元破坏了封装性,降低了程序的可维护性。因此使用友元时要慎重的权衡得失后再决定。2)因为友元函数不是类的成员,故在友元函数中没有this指针,因此必须通过函数参数来传递对象。

    2:友元类:若一个类为另一个类的友元,则次类的所有成员函数都能访问对方类的私有成员。下例所示:类B的所有成员函数都是类A的友元函数,都能够访问类A的所有成员。但是类A不是类B的友元类

    Eg:class A

    {

        ……

    public:

        friend class B;

        ……

    };

     

    展开全文
  • C++类和对象(下)——初始化列表、static成员友元

    千次阅读 热门讨论 2021-03-08 09:23:18
    C++类和对象(上)——类的基本概念、类的限定符及封装和类成员函数的this指针 C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载) 一、再谈构造函数 1.1 构造函数整体赋值 在创建对象时...


    关于C++类和对象的学习
    C++类和对象(上)——类的基本概念、类的限定符及封装和类成员函数的this指针
    C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载)
    在这里插入图片描述

    一、再谈构造函数

    1.1 构造函数整体赋值

    在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。例如我们之前创建的Date类

    class Date
    {
    public:
    
    	Date(int year = 1900, int month = 1, int day = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    

    虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称作为类对象成员的初始化,构造函数体中的语句只能将其称作为赋初值,而不能称作初始化因为初始化只能初始化一次,而构造函数体内可以多次赋值

    1.2 初始化列表

    <1>为什么有初始化列表?

    对于我们定义的日期类,当类中出现以下成员时,如果只用构造函数则无法完成变量的初始化了,以下的成员变量需要在定义的时候就需要初始化

    • 引用成员变量
    • const成员变量
    • 自定义类型的成员变量

    在这里插入图片描述
    其次对于自定义的类成员变量,不使用初始化列表会调用多次构造函数
    在这里插入图片描述

    <2> 如何使用初始化列表

    初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式
    注意:每个成员变量在初始化列表中只能出现一次

    //1.2.2
    class Time
    {
    public:
    	Time(int hour = 1, int minute=1,int second = 1)
    		:_hour(hour)
    		,_minute(minute)
    		,_second(second)
    	{
    		cout << "Time(int hour = 1, int minute=1,int second = 1)" << endl;
    	}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    
    class Date
    {
    public:
    	//初始化列表写法
    	Date(int year=1900, int month=1, int day=1,int hour=1,int minute=1,int second=1)
    		:_year(year)
    		,_month(month)
    		,_day(day)
    		,_n(10)
    		,_ref(day)
    		,_t(hour,minute,second)
    	{
    		cout << "Date(int year, int month, int day,int hour,int minute,int second)" << endl;
    
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    
    	//定义的时候需要初始化
    	int& _ref;	//引用
    	const int _n; //const成员变量
    	Time _t;	//自定义类型的成员变量
    };
    
    void Test2()
    {
    	Date d1(2021,3,9,2,2,2);
    }
    

    结果在这里插入图片描述

    <3> 成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关

    如下代码的运行结果是什么?

    //1.2.3
    class A
    {
    public:
    	A(int a)
    		:_a1(a)
    		, _a2(_a1)
    	{}
    	void Print() {
    		cout << _a1 << " " << _a2 << endl;
    	}
    private:
    	int _a2;
    	int _a1;
    };
    
    void Test2()
    {
    	A aa(1);
    	aa.Print();
    }
    

    结果

    在这里插入图片描述

    1.3 explicit关键字

    <1> 匿名对象

    匿名对象顾名思义就是没有名字,其作用域只在一行中有效,例如下面的代码

    //1.3.1
    class B
    {
    public:
    	B(int b = 0)
    		:_b(b)
    	{
    		cout << "B(int b = 0)" << endl;
    	}
    
    	//析构函数
    	~B()
    	{
    		cout << "~B()" << endl;
    	}
    private:
    	int _b;
    };
    
    int main()
    {
    	B bb(10);	//生命周期在main函数域
    	B(2);	//匿名对象生命周期在这一行
    	return 0;
    }
    

    在这里插入图片描述
    在这里插入图片描述

    <2> 为什么有explicit关键字?

    对于c++来说,构造函数不仅可以构造与初始化对象,对于单个参数的构造函数,还具有类型转换的作用

    当我们定义一个类进行初始化时,如果我们采取下面这种定义方式,编译器会自动生成一个匿名对象,然后用匿名对象对cc对象进行拷贝构造

    //1.3.2
    class C 
    {
    public:
    	C(int c)
    		:_c(c)
    	{
    		cout << "C()" << endl;
    	}
    
    private:
    	int _c;
    };
    
    int main()
    {
    	C cc(2);
    	cc = 8;	//编译器会自动生成一个匿名对象,然后用匿名对象对cc对象进行拷贝构造
    	return 0;
    }
    

    <3> 如何使用explicit关键字?

    用explicit修饰构造函数,将会禁止单参构造函数的隐式转换

    //1.3.3
    class C 
    {
    public:
    	explicit C(int c)
    		:_c(c)
    	{
    		cout << "explicit C(int c)" << endl;
    	}
    
    private:
    	int _c;
    };
    
    int main()
    {
    	C cc(2);
    	cc = 8;	//编译器会自动生成一个匿名对象,然后用匿名对象对cc对象进行拷贝构造
    	return 0;
    }
    

    在这里插入图片描述

    二、static成员

    2.1 概念

    声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数。静态的成员变量一定要在类外进行初始化

    面试题:实现一个类,计算程序中创建出了多少个类对象?这个时候我们就可以使用static成员变量和static成员函数来实现

    //2.1 实现一个类,计算程序中创建出了多少个类对象。
    class A
    {
    public:
    	//构造函数
    	A()
    	{
    		++_scount;
    	}
    	//拷贝构造函数
    	A(const A& a)
    	{
    		++_scount;
    	}
    	
    	static int GetAcount()
    	{
    		return _scount;
    	}
    private:
    	static int _scount;
    };
    
    //初始化在类外
    int A::_scount = 0;
    
    void TestA()
    {
    	cout << A::GetAcount() << endl;
    	A aa;
    	A bb;
    	A cc(bb);
    	cout << A::GetAcount() << endl;
    }
    

    在这里插入图片描述

    2.2 特性

    <1> 静态成员为所有类对象所共享,不属于某个具体的实例

    <2> 静态成员变量必须在类外定义,定义时不添加static关键字

    在这里插入图片描述

    <3> 类静态成员即可用类名::静态成员或者对象.静态成员来访问

    在这里插入图片描述

    <4> 静态成员函数没有隐藏的this指针,不能访问任何非静态成员

    在这里插入图片描述

    <5>静态成员和类的普通成员一样,也有public、protected、private3种访问级别,也可以具有返回值

    Q1: 静态成员函数可以调用非静态成员函数吗?

    不可以,因为静态成员函数没有隐藏的this指针

    Q2:非静态成员函数可以调用类的静态成员函数吗?

    可以,因为非静态成员函数含有this指针,指定了静态成员函数的类域
    在这里插入图片描述

    三、C++11的成员初始化新玩法

    3.1 为什么?

    对于C++98而言,类内自定义的内置类型,编译器会进行初始化,而其他内置类型不会,因此出现则会中初始化方法。
    具体查看这篇博客的2.2.7节内容
    C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载)
    在这里插入图片描述

    3.2 怎么用?

    C++11支持非静态成员变量在声明时进行初始化赋值,但是要注意这里不是初始化,这里是给声明的成员变量缺省值

    //3.C++11的成员初始化新玩法
    class B
    {
    public:
    	B(int b = 0)
    		:_b(b)
    	{}
    	int _b;
    };
    class A
    {
    public:
    	void Print()
    	{
    		cout << a << endl;
    		cout << b._b << endl;
    		cout << p << endl;
    	}
    private:
    	// 非静态成员变量,可以在成员声明时给缺省值。
    	int a = 10;
    	B b = 20;
    	int* p = (int*)malloc(4);
    	//静态成员不可以
    	static int n;
    };
    int A::n = 10;
    
    int main()
    {
    	A a;
    	a.Print();
    	return 0;
    }
    

    在这里插入图片描述

    四、友元

    • 友元分为:友元函数友元类
    • 友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用

    4.1 友元函数

    问题:现在我们尝试去重载operator<<,然后发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象,才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话,又会导致类外没办法访问成员,那么这里就需要友元来解决。operator>>同理

    //4.1
    class Date
    {
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
    	ostream& operator<<(ostream& _cout)
    	{
    		_cout << _year << "-" << _month << "-" << _day;
    		return _cout;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
    	Date d(2017, 12, 24);
    	d << cout;
    	return 0;
    }
    

    在这里插入图片描述
    友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字

    //4.1
    class Date
    {
    friend ostream& operator<<(ostream& _cout, const Date& d);
    friend istream& operator >> (istream& _cin, Date& d);
    
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
    	ostream& operator<<(ostream& _cout)
    	{
    		_cout << _year << "-" << _month << "-" << _day;
    		return _cout;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    ostream& operator<<(ostream& _cout, const Date& d)
    {
    	_cout << d._year << "-" << d._month << "-" << d._day << endl;
    	return _cout;
    }
    
    istream& operator >> (istream& _cin, Date& d)
    {
    	_cin >> d._year >> d._month >> d._day;
    
    	return _cin;
    }
    
    int main()
    {
    	Date d(2017, 12, 24);
    	cout<<d;
    	//Date d1;
    	cin >> d;
    	cout << d;
    	return 0;
    }
    

    在这里插入图片描述

    4.2 友元类

    友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。

    • 友元关系是单向的,不具有交换性。
      比如下面Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
    • 友元关系不能传递
      如果B是A的友元,C是B的友元,则不能说明C时A的友元。
    class Date; // 前置声明
    class Time
    {
    	friend class Date; // 声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量
    public:
    	Time(int hour=0, int minute=0, int second=0)
    		: _hour(hour)
    		, _minute(minute)
    		, _second(second)
    	{}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    
    class Date
    {
    public:
    	Date(int year = 1900, int month = 1, int day = 1)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
    
    	void SetTimeOfDate(int hour, int minute, int second)
    	{
    		// 直接访问时间类私有的成员变量
    		_t._hour = hour;
    		_t._minute = minute;
    		_t._second = second;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    
    	Time _t;
    };
    

    五、内部类

    概念:如果一个类定义在另一个类的内部,这个内部类就叫做内部类。注意此时这个内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

    注意:内部类就是外部类的友元类。注意友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

    特性:

    1. 内部类可以定义在外部类的public、protected、private都是可以的。
    2. 注意内部类可以直接访问外部类中的static、枚举成员,不需要外部类的对象/类名。
    3. sizeof(外部类)=外部类,和内部类没有任何关系
    class A
    {
    private:
    	static int k;
    	int h;
    public:
    	class B
    	{
    	public:
    		void foo(const A& a)
    		{
    			cout << k << endl;//OK
    			cout << a.h << endl;//OK
    		}
    	};
    };
    int A::k = 1;
    int main()
    {
    	A::B b;
    	b.foo(A());
    	return 0;
    }
    
    展开全文
  • C++类和对象实例解析

    千次阅读 2017-01-12 11:08:29
    C++类和对象实例解析
    这篇文章主要介绍了C++类和对象,从定义出发再到实例解析,深入的理解C++类和对象,需要的朋友可以参考下

    C++既是面向对象也是面向过程的语言,在这里就有一个重要的概念——
            何谓类?类是对对象的一种抽象,举例来讲:每一个实实在在存在的人就是一个对象,人有很多共同的特征(一个头,两条腿,能走,能跑),这具有共同特征的人就成为一个类。类是一个抽象的名词,每一个人(即对象)是这个类的实例。
            对象间具有的共同特征是对象的属性和行为。录像机是一个对象,它的属性是生产厂家、牌子、重量、颜色等等,它的行为就是它的功能,如录像、放像、快进、倒退等操作。
    C++程序中,需要先定义一个类,形如:
      Class 类名
         { 
            定义变量;
            ….
            定义函数
          }
    在类体中时成员列表,包括数据和操作数据的函数,即数据成员、成员函数。这体现了类的封装性和信息的隐蔽性。
    成员函数一般在类体中声明,在类体外定义。
    构造函数:对对象进行赋值
    析构函数:在函数功能域结束时,释放对象成员的空间。
    内联函数:为了节省函数调用的时间
    完成各种功能函数…….
    定义对象就需要对类进行实例化。形如:类名对象名

            类是一个抽象,它不占任何内存,只有当其实例化成为对象之后,才会给其分配空间。
            计算机中就是用对象来描述大千世界的事物。对象之间通过消息建立联系,借助函数完成各种各样的功能。
    简单的说,这就是对象和类。

    下面通过实例理解

    【2-1】定义一个日C++类和对象期类date,该类对象存放一个日期,可以提供的操作有:取日期值,取年份,提取月份,提取日期以及设计日期值。
    【分析】这个程序需要先定义一个类类型,这个类的数据成员有year,month,day,并且将其设计为private访问权限。还需要有5个成员函数,分别为:

    void getdate();          //取日期值,格式为“year-month-day”
    int getyear();          //取年份
    int getmonth();         //取月份
    int getday();          //取日期
    void setdate(int y,int m,int d);    //设置日期值
    程序代码如下:
    #include <iostream>
    using namespace std;
    class date
    {
    public:
     void getdate();
     int getyear();
     int getmonth();
     int getday();
     void setdate(int y,int m,int d);
    private:
     int year,month,day;
    };
    int date::getyear(){ return year; }
    int date::getmonth(){ return month; }
    int date::getday(){ return day; }
    void date::getdate()
    { cout<<"today is:"<<year<<"-"<<month<<"-"<<day<<endl; }
    void date::setdate(int y,int m,int d)
    { year=y; month=m; day=d;  }
    int main()
    {
     date d;
     d.setdate(2011,2,1);
     cout<<"year="<<d.getyear()<<endl;
     cout<<"month="<<d.getmonth()<<endl;
     cout<<"day="<<d.getday()<<endl;
     d.getdate();
     return 0;
    }
    

    【总结】这是一个最简单的类程序,但其中也存在不少问题。比如,如果没有setdate()函数,就无法对对象赋初值,而且必须按照特定的格式对对象进行设置初值。这个问题就应该采用构造函数来进行对象初始化。
    【2-2】对例【2-1】进行改进,要求使用构造函数进行对象初始化,并且格式要不一致。
    【分析】这个例子需要使用构造函数,并且要用到构造函数重载,使用默认参数值的构造函数和拷贝构造函数。
    程序代码如下:

    #include <iostream>
    using namespace std;
    class date
    {
    public:
     date(int y=0,int m=0,int d=0)
     { year=y; month=m; day=d; }
     date(date &d)
     { year=d.year; month=d.month; day=d.day; }
     void getdate()
     { cout<<"today is:"<<year<<"-"<<month<<"-"<<day<<endl; }
     int getyear() { return year; }
     int getmonth() { return month; }
     int getday() { return day; }
    private:
     int year,month,day;
    };
    
    int main()
    {
     date d1(2011,2,1),d2,d3(d1);
     d1.getdate();
     d2.getdate();
     d3.getdate();
     return 0;
    }
    
    

    【总结】程序中的对象d1有完整的实参表,则调用构造函数来进行对象初始化;对象d2没有实参表,系统同样自动调用构造函数进行对象初始化,只不过形参的值采用默认参数值进行初始化。对于对象d3,则采用拷贝构造函数进行初始化。
    【2-3】输入数据到数组内求和、最大值、最小值与平均值后输出,将成员函数定义在类外。
    【分析】这个程序时对C语言中所学内容的一个总结,是从面向过程到面向对象的跨越。这个类的数据成员应该包括数组。成员函数应该有数组输入函数、数组输出函数、求和函数、最大值函数、最小值函数和求平均值函数。
    程序代码如下:

    #include <iostream>
    using namespace std;
    #define N 10
    class array
    {
    public:
     void input();
     void output();
     int max();
     int min();
     int sum();
     float average();
    private:
     int a[N],maxnumber,minnumber,sumnumber;
     float avenumber;
    };
    void array::input()
    {
     int i=0;
     cout<<"Please input "<<N<<" numbers:"<<endl;
     for(i=0;i<N;i++)
     {
     cout<<"a["<<i<<"]=";
     cin>>a[i];
     }
    }
    void array::output()
    {
     int i=0;
     cout<<"array a is:"<<endl;
     for(i=0;i<N;i++)
     cout<<a[i]<<" ";
     cout<<endl;
    }
    int array::max()
    {
     int i;
     maxnumber=a[0];
     for(i=1;i<N;i++)
     if(maxnumber<a[i])
      maxnumber=a[i];
     return maxnumber;
    }
    int array::min()
    {
     int i;
     minnumber=a[0];
     for(i=1;i<N;i++)
     if(minnumber>a[i])
      minnumber=a[i];
     return minnumber;
    }
    int array::sum()
    {
     int i;
     sumnumber=a[0];
     for(i=1;i<N;i++)
     sumnumber+=a[i];
     return sumnumber;
    }
    float array::average()
    {
     float ave=static_cast<float>(sumnumber/N);
     return ave;
    }
    int main()
    {
     array a;
     a.input();
     a.output();
     cout<<"The max number is "<<a.max()<<endl;
     cout<<"The min number is "<<a.min()<<endl;
     cout<<"The sum number is "<<a.sum()<<endl;
     cout<<"The average number is"<<a.average()<<endl;
      return 0;
    }
    

    【总结】从上面的程序可以看出,类array里面包括对数组的各种操作,包括求和,求最大值,求最小值以及求平均值等。
    【2-4】设计一个表示猫的类,包括猫的颜色、体重、年龄等数据,具有设置猫的颜色,修改和显示猫的体重、年龄等操作。
    【分析】设计猫类的类名为Cat,此类有3个数据成员,颜色用string类表示,可以存放汉字,体重用实数类型表示,年龄用整数型表示,为了保护数据的安全性,3个数据成员全部为私有性。对猫的属性数据的设置和修改,全部为公有函数。
    程序代码如下:

    #include <iostream>
    #include <string>
    using namespace std;
    class Cat
    {
    public:
     Cat(string c="red",float w=1,int a=1);
     string get_color();
     float get_weight();
     int get_age();
     void display();
    private:
     string color;
     float weight;
     int age;
    };
    Cat::Cat(string c,float w,int a)
    {
     color=c;
     weight=w;
     age=a;
    }
    string Cat::get_color()
    {
     return color;
    }
    float Cat::get_weight()
    {
     return weight;
    }
    int Cat::get_age()
    {
     return age;
    }
    void Cat::display()
    {
     cout<<"The color of this cat is "<<get_color()<<endl;
     cout<<"The weight of this cat is "<<get_weight()<<endl;
     cout<<"The age of this cat is "<<get_age()<<endl;
    }
    int main()
    {
     Cat c1,c2("yellow",1,2);
     cout<<"c1 is:"<<endl;
     c1.display();
     cout<<"c2 is:"<<endl;
     c2.display();
     return 0;
    }
    

    【总结】从上面的程序可以看出,构造函数可以用类对对象进行初始化,并且构造函数可以进行重载。

    希望本文可以对大家学习c++编程语言有所帮助,也希望大家可以继续关注!

    展开全文
  • C++类和对象的概念

    千次阅读 2018-06-10 17:31:13
    C++类和对象的概念 面向对象程序设计 概念:(Object Oriented Programming,缩写:OOP)是一种程序开发的方法。 对象指的是的实例,将对象作为程序的基本单元,将程序数据封装其中,以提高软件的重用性、...
  • C++类和对象的使用之对象指针

    千次阅读 多人点赞 2019-07-04 21:38:07
    C++中,可以说明指向的数据成员成员函数的指针。 对象指针遵循一般变量指针的各种规则:类名 *对象指针名; 对象指针名*成员名; 对象指针在使用之前,也一定要先进行初始化,让它指向一个已经声明过的对象,...
  • C++类和对象概念

    千次阅读 2016-08-06 20:13:06
    C++是一门面向对象的编程语言,理解C++,首先要理解对象这两个概念。 C++中的可以看做C语言中结构体(Struct)的升级版。结构体是一种构造数据类型,可以包含若干成员(变量),每个成员的数据类型可以不...
  • C++类和对象,结构体

    千次阅读 2016-09-15 10:48:24
     C和C++规定可以用一个结构体,里面即可有数组,也可以有其他变量。C中成员只能是数据,C++除了数据,还可以是函数。  但是,C++提供了这个东西,所以不需要包含函数的结构体。 1,结构体: #include using ...
  • c++ 对象 声明 创建对象 new
  • 使用的组合(线段Line中包含点Point成员): #include &lt;iostream&gt; #include &lt;cmath&gt; using namespace std; //Point的定义 class Point { public: Point(int xx = 0, int yy ...
  • c++类对象(1)F&A Q1:定义或说明对象时,系统会自动调用构造函数为创建的对象初始化。如果中没有定义任何构造函数时,就无法给定义的对象初始化。 这句话是错误的。如果没有定义任何构造函数的时候,系统...
  • C++对象和类指针的区别

    万次阅读 多人点赞 2019-04-17 20:57:28
    一篇转载率较高的帖子:C++ 类对象和 指针的区别 大佬都不贴结果。。。。所以这里我给出代码和结果: #include<iostream> using namespace std; class Test{ public: int a; Test(){ a = 1; } }; ...
  • C++ 对象

    千次阅读 2012-09-06 13:58:30
    今天主要讲的构成,成员函数以及对象的定义使用。  1.其实这一节,对于用C#开发的人来说,简直就是驾轻就熟啊。C++类的构成,我想从C的结构体开始说起。C中的结构体我想大家在熟悉不过了。 1 #include ...
  • c++类成员对象

    千次阅读 2018-06-11 18:00:52
    成员对象:当一个的成员是另一个对象时,这个对象就叫成员对象。 成员对象的构造与析构 1、出现成员对象时,如果成员对象的构造函数是有参构造函数,则该的初始化列表需要对成员对象进行初始化。 class ...
  • C++创建类对象方法动态对象数组

    千次阅读 2019-03-17 16:03:57
    创建类对象的方法 C++中有两种创建对象的方法,一种是直接声明,另一种则是使用new关键字,虽然作用相同,但是它们底层的存储方式却完全不同。在此之前,我们先了解一下C++程序的存储形式。 C++程序的内存格局通常...
  • C++类对象_简单练习题

    千次阅读 多人点赞 2019-03-25 17:19:33
    ## C++ 对象练习题: **在主函数中生成一个时钟对象,并为其设置时间显示时间** 这是一道入门题,主要是为了熟悉对象,以及成员函数,数据成员的实现; 在此先强调几点与C的区别或者说创建对象的...
  • C++ 对象的习题练习

    千次阅读 多人点赞 2019-05-17 23:58:00
    定义一个 Point 表示平面上的一个点,在定义一个 Rectangle表示平面上的矩形,用 Point 对象作为Rectangle成员描述平面上矩形的顶点坐标。要求 Point中有相应的成员函数可以读取点的坐标值, Rectangle...
  • C++ 类和对象成员特性

    万次阅读 2020-07-18 19:56:37
    //当中成员是其他类对象时,我们称该成员为对象成员 //构造的顺序是:先调用对象成员的构造,再调用本构造 //析构顺序与构造相反 #include <iostream> using namespace std; #include <string> ...
  • c++类对象作为方法参数(即函数参数)

    千次阅读 多人点赞 2019-09-12 17:13:03
    c++类对象作为参数传递时,有三种传递方式 #include <iostream> using namespace std; //求圆的面积 class Mycircle{ public: double r; double s; public: double getR(){ return r; } void setR...
  • C++类的对象和类的指针的区别

    万次阅读 2011-02-10 16:07:00
    对于一个对象和这个的指针(用new运算符分配内存)在应用时有何区别   1.和对象是两回事,对象是的实例;   2.对象是在栈中分配的,使用new生成的对象是在堆中分配的;   3.要发挥虚函数的强大作用,必须...
  • C++中对类和对象基础理解

    千次阅读 多人点赞 2017-03-04 17:41:28
    C++中对类和对象基础理解 C++不是纯面向对象的编程语言,而是基于面向对象的语言,因为C++中包含C语言的部分,而C语言是面向过程的。 面向对象的三大特性:封装、继承、多态。 封装:将方法数据封装在里面,...
  • c++关于类和对象的实例

    千次阅读 2017-10-24 20:41:34
    c++是面向对象的程序设计。 重要的概念:对象、数据成员、成员函数、共有、私有。 具体实例如下: http://c.biancheng.net/cpp/biancheng/view/2162.html 定义一个,定义此类的对象,引用的多个成员 引用...
  • class Date { public: Date(int year = 1900, int month = 1, int day = 1) //构造函数 { _year = year; _month =... //对象的命名风格 int _month; int _day; };

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 937,079
精华内容 374,831
关键字:

c++类和对象

c++ 订阅