webpackwebpack12-10 16:50

C++基础(类和构造函数)

C++基础

类和构造函数

  • 类:类是定义同一类所有对象得变量和方法的蓝图或原型。数据与算法的统一。

    • 成员
    • 成员函数
    • 保护数据
    • 封装
  • 类和对象就像人类与人的关系

  • 对象的初始化

    • 建立对象,须有一个有意义的初始值
    • C++建立和初始化对象的过程专门由该类的构造函数来完成。
    • 构造函数给对象分配空间和初始化。
    • 如果一个类没有专门定义构造函数,那么C++就仅仅创建对象而不做任何初始化
#include <iostream>
using namespace std;
class Person
{
    private:
        int id;
        int money;
    public:
        void show()
        {
            cout<<"id="<<id<<"money="<<money<<endl;
        }
        void set(int a,int b)
        {
            if(a<0)
                a=0;
            id=a;
            money=b;
        }
};
int main()
{
    Person a;
    Person b;
    a.set(1,100);
    a.show();
    b.set(2,300);
    b.show();
}
class Person
{
    private:
        int id;
        int money;
    public:
        void show();
        void set(int a,int b);
};
void Person::show()
{
    cout<<"id="<<id<<"money="<<money<<endl;
}
void Person::set(int a,int b)
{
    if(a<0)
        a=0;
    id=a;
    money=b;
}
  • 最终版
//main.cpp
#include "person.h"
int main()
{
    Person a;
    Person b;
    a.set(1,100);
    a.show();
    b.set(2,300);
    b.show();
}
//person.cpp
#include <iostream>
#include "person.h"
using namespace std;
void Person::show()
{
    cout<<"id="<<id<<"money="<<money<<endl;
}
void Person::set(int a,int b)
{
    if(a<0)
        a=0;
    id=a;
    money=b;
}
//person.h
#include "person.h"
class Person
{
    private:
        int id;
        int money;
    public:
        void show();
        void set(int a,int b);
};
  • class默认私有。

  • 面向对象

    • 在面向对象中,算法与数据结构被捆绑为一类
  • 定义成员函数

    • 类中定义成员函数一般为头连函数,即没有明确用。。。。。。。。。
  • 保护成员

    • 保护成员
      • 除了友元和子类的成员函数之外,从类的外部就不能对它们访问
    • 私有成员
      • 从类的外部就不能对它们访问
    • 公共成员
      • 公共成员在任何地方都可以被访问。
  • 不同域对应不同的函数内容

#include <iostream>
using namespace std;        
class person
{
    private:
        int id;
        int money;
    public:
        void show();
        void show(int a);
};
class test
{
    public:
        void show();
};
void person::show()
{
    cout<<"hello1"<<endl;
}
void person::show(int a)
{
    cout<<"hello2"<<endl;
}
void test::show()
{
    cout<<"hello3"<<endl;
}
void show()
{
    cout<<"hello4"<<endl;
}
int main()
{
    person a;
    test b;
    a.show();
    a.show(1);
    show();
    b.show();
}
  • 对象与域的调用方法
#include <iostream>
using namespace std;
class test
{
    public:
        void show()
        {
            cout<<"hello"<<endl;
        }
};
void lianxi1(test *p1)
{
    p1->show();
}
void lianxi2(test &p2)
{
    p2.show();
}
void lianxi3(test p3)
{
    p3.show();
}
int main()
{
    test t;
    lianxi1(&t);
    lianxi2(t);
    lianxi3(t);
    cout<<sizeof(test)<<endl;
}
#include <iostream>
using namespace std;        
class test
{
    private:
        int id;
    public:
        void setid(int i)
        {
            id=i;
        }
        void show()
        {
            cout<<"this"<<(this)<<endl;
            cout<<"id= "<<(id)<<endl;
        }       
};
int main()
{
    test t;
    t.setid(222);
    t.show();
    cout<<"&t="<<&t<<endl;

}
  • 类和struct的区别
    • 除关键字不同外(class,struct)的唯一区别是,结构在默认情况下的成员是公共的,而类在默认情况下的成员是私有的。 在C++中,结构是特殊的类。
  • 类的作用域
    • 一个类的所有成员位于这个类的作用域内
    • 类作用域是类定义和相应类成员定义范围
  • 对象和类的联系与区别

  • 类中访问控制的关键字有哪几个,分别是什么意义

  • 封装理念
    • 封装来源于信息隐藏的设计理念, 是通过特性和行为的组合来创建新数据类型让接口与具体实现相隔离。
    • C++中是通过类来实现的, 为了尽量避免某个模块的行为干扰同一系统中的其它模块,应该让模块仅仅公开必须让外界知道的接口。
  • 封装的优点
    • 重用
    • 不必关心具体的体现
    • 具有安全性

构造函数

  • 定义
    • C++的构造函数和析构,使类对象能轻松的被赋值与撤销。它们是一种特殊的函数。
    • 构造函数是第一个自动调用的函数
    • 构造函数创建类对象,初始化其成员
    • 析构函数撤销类对象
    • 构造函数和析构函数是类的特殊成员函数
    • 与类同名
    • 析构函数
    • 重载构造函数
    • 默认参数构造函数
    • 对象创建过程
#include<iostream>
using namespace std;
class Fract
{
    int m_m;
    int m_z;
public:
      Fract(int z,int m);
      Fract();
      void set(int z,int m)
      {
        m_m=m;
        m_z=z;
      }//set函数依旧保留,以防后续使用。
      void print()
      {
        reduce();
        cout<<m_z<<"/"<<m_m<<endl;
      }
      void reduce()
      {
        for(int i=m_m;i>0;i--)
        {
            if((m_m%i==0)&&(m_z%i==0))
            {
                m_m/=i;
                m_z/=i;
                break;
            }
        }
      }
};
Fract::Fract(int z,int m)
{
    m_m=m;
    m_z=z;
}
Fract::Fract()
{
    m_m=12;
    m_z=16;
    //-cout<<"hello"<<endl;
}
int main()
{
    Fract a(12,16);
//  a.set(12,16);
    a.print();
    Fract b;//一般不用(),会出错。
//  a.set(12,16);
    b.print();
    //-Fractc[5];会调用5次
}
  • 注意
    • 类名==构造函数名
    • 构造函数没有返回值类型,函数体也不允许返回值,但可以有返回语句"return".
  • 建立对象的同时,自动调用构造函数
#include <iostream>
using namespace std;
class test1
{
    public:
        test1()
        {   
            cout<<"hello test1"<<endl;
        }
        
};
class test2
{
    test1 m_t;
    public:
        test2()
        {
            cout<<"hello test2"<<endl;
        }
};
int main()
{
    test2 t;
}
  • 类中成员变量也是类,调用顺序:
#include <iostream>
using namespace std;
class test1
{
    int m_a;
    public:
        test1(int a)
        {   
            m_a=a;
            cout<<"hello test1"<<m_a<<endl;
        }
        test1(){}
};
class test2
{
    test1 m_t;
    test1 m_s;
    public:
        test2()
        {
            cout<<"hello test2"<<endl;
        }
};
int main()
{
    test2 t;
}
//test2()后调用赋值11出现hello test111+hello test2
//不调用则出现hello test2
#include <iostream>
using namespace std;
class test1
{
    int m_a;
    public:
        test1(int a)//
        {   
            m_a=a;
            cout<<"hello test1"<<m_a<<endl;
        }
        test1(){}
        ~test()
        {
            cout<<"析构测试1"<<endl;
        }
};
class test2
{
    test1 m_t;
    test1 m_s;
    public:
        test2():m_s(222),m_t(333)
        {
            cout<<"hello test2"<<endl;
        }   
        ~test2()
        {
            cout<<"析构测试2"<<endl;
        }
        
};
int main()
{
    test2 t;
    cout<<"+++"<<endl;
}
//hello test1333
//hello test1222
//hello test2
//+++
//析构测试2
//析构测试1222
//析构测试1333
  • 析构函数

    • 在t消亡的时候自动调用,无返回值。
    • 析构函数不允许重载。
    • 析构函数有且只有一个。
    • 析构函数是特殊的类成员函数,不能随意调用
  • 析构函数之防止内存泄漏

#include <iostream>
#include <malloc.h>
using namespace std;
class test
{
    int *p;
    public:
        test()
        {
            p=(int *)malloc(sizeof(int));
            *p=4;
            cout<<"test construct"<<endl;
        }
        ~test()
        {
            free(p);
            cout<<"析构测试"<<endl;
        }
        void print()
        {
            cout<<*p<<endl;
        }
};
int main()
{
    test t;
    t.print();
    cout<<"+++++++"<<endl;
}
//test construct
//4
//++++++
//析构测试
  • 手动创建构造函数是创建一个无名函数

  • C++给构造对象的顺序做了专门的规定

    • 局部和静态对象,以声明顺序构造
    • 静态对象只能被构造一次
    • 所有全局对象都在主函数main()之前被构造
    • 全局对象构造时无特殊顺序
    • 成员以其在类声明的顺序构造
  • 构造函数在分配空间之后被调用

bool型变量

#include <iostream>
using namespace std;
int main()
{
    bool bSex=true;
    cout<<"请输入数字"<<endl;
    cin>>bSex;
    cout<<"我叫SB,是一位"<<(bSex?"丑逼":"帅逼")<<endl;
    cout<<"true="<<true<<endl;
    cout<<"false="<<false<<endl;
}
  • 分配与释放顺序
#include <iostream>
using namespace std;
class test
{
    int m_data;
    public:
        test(int data):m_data(data)
        {
            cout<<"test("<<m_data<<")"<<endl;
        }
        ~test()
        {
            cout<<"~test("<<m_data<<")"<<endl;
        }
};
test t1(10);
void fun()
{
    test t4(40);
    return;
}
void show()
{
    static test t5(50);
    return;
}
int main(int argc,char **argv)
{
    test t2(20);
    test t3(30);
    fun();
    show();
}
test t6(60);
  • 类和构造函数制造时钟
#include <iostream>
#include <stdlib.h>
#include <unistd.h>
using namespace std;
class myClock
{
    private:
        int myHour;
        int myMin;
        int mySecond;
    public:
        myClock();
    //  void set(int hour,int min,int second);
        void Time();
        void show();
        void run();
};
myClock::myClock():myHour(23),myMin(59),mySecond(55)
{
}
/*
void myClock::set(int hour,int min,int second)
{
    myHour=hour;
    myMin=min;
    mySecond=second;
}*/
void myClock::Time()
{

        sleep(1);
        mySecond++;
        if(mySecond==60)
        {   
            myMin++;
            if(myMin==60)
            {
                myHour++;
                if(myHour==24)
                {
                    myHour=0;
                }
                myMin=0;
            }
            mySecond=0;
        }
    
}
void myClock::show()
{
    cout<<myHour<<":"<<myMin<<":"<<mySecond<<endl;
}
void myClock::run()
{
    while(1)
    {
        system("clear");
        show();
        Time();
    }
}
int main()
{
    myClock c;
//  c.set(23,59,55);
    c.run();
}

官场书屋二维码

小额赞赏

000
评论