c++学习

struct声明的类都默认为public，要想分别指明私有成员和共有成员，需要使用private和public。

class声明的类默认都是pubulic，如果想分别指明私有和共有成员，需要使用private和public。

 

如果成员函数在类体内都默认为内置函数。如果成员函数不在类体内定义，而在类体外，系统不把它默认为内置函数（inline），调用这些成员函数跟调用普通函数的过程是一样的。类声明和成员函数定义的分离：

在调用内置成员函数时，系统并不是真正的执行函数的调用过程，而是把函数代码嵌入程序的调用点，这样可以大大减少调用成员函数的时间开销。

#include<iostream>
using namespace std;
class Time{
public:
    void set_time(void);
    void show_time(void);
private:
    int hour;
    int minute;
    int sec;
} ;                  //类声明，公用函数原型声明





int main()
{
    Time t;
    t.set_time();         //使用类函数
    t.show_time();
}

void Time::set_time(void)  //定义类外类函数
{
    cin>>hour;
    cin>>minute;
    cin>>sec;
}

void Time::show_time(void)
{
cout<<hour<<": "<<minute<<": "<<sec<<endl;
}

需要计算一个长方体的体积：

#include<iostream>
using namespace std;
class Volume{
public:
    int tiji(void);
    void show_tiji(void);
private:
    int length;
    int wide;
    int high;
    int v;
} ;





int main()
{
    Time t;
    t.tiji();
    t.show_tiji();
}

int Volume::tiji(void)
{
    cin>>length;
    cin>>wide;
    cin>>high;
    v=length*wide*high;
    return v;
}

void Volume::show_tiji(void)
{
cout<<"tiji: "<<v<<endl;
}

不能在类定义中对数据成员进行初始化工作，因为类并不是一个实体，而是一种抽象类型，并不占用存储空间，无处容纳数据。可以在定义对象时对数据成员初始化：

Time t1={1,2,3}

对private和protected定义的变量都不能定义。使用构造函数来解决问题：构造函数的名字必须与类名同名，不能由用户任意命名，以便编译系统能够识别它并把它作为构造函数来处理。它不具有任何类型，不反悔任何值。构造函数的功能由用户定义，用户根据初始化的要求设计函数体和函数参数。

#include<iostream>
using namespace std;
class Time
{
public:
    Time(){
        hour=0;
        minute=0;
        sec=0;
            }
    void set_time();
    void show_time();
private:
    int hour;
    int minute;
    int sec;
};

void Time::set_time()
{
cin>>hour;
cin>>minute;
cin>>sec;
}

void Time::show_time()
{
cout<<hour<<":"<<minute<<":"<<sec<<":"<<endl;
}

构造函数Time（）{}也可以先声明后在类外定义：Time：：Time（）{}。

 

带参数函数的构造函数：构造函数首部的一般格式：构造函数 （类型1 形参1 类型2 形参2 。。。）

定义对象的一般格式：类名 对象名（实参1 实参2.。。。）

#include<iostream>
using namespace std;
class Box
{
public:
    Box(int l,int w,int h){
        length=l;
        width=w;
        high=h;
            }
    int volume();
private:
    int length;
    int width;
    int high;
};

int Box::volume()
{
return length*width*high;
}



int main()
{
Box b1(12,25,30);
cout<<b1.volume()<<endl;
Box b2(15,30,21);
cout<<b2.volume()<<endl;
return 0;

 

也可以这么做：

#include
using namespace std;
class Box
{
public:
 Box(int l,int w,int h);
 int volume();
private:
 int length;
 int width;
 int high;
};
Box::Box(int l,int w,int h):length(l),width(w),high(h){};
int Box::volume()
{
return length*width*high;
}

 

int main()
{
Box b1(12,25,30);
cout<Box b2(15,30,21);
cout<return 0;
}

 

在类中使用Box(int =10,int =10,int =10);  //声明一个全部参数都指定默认值的构造函数

          Box();//声明无参数的构造函数，是重载构造函数

          Box();//声明有两个参数的构造函数，是重载函数

 

析构函数是一个特殊的成员函数，它的作用与构造函数相反，在类的名字前加一个“~”符号。

析构函数的作用并不是删除对象，而是撤销对象占用的内存之前完成一些清理工作，这部分内存可以被程序分配给新对象使用。析构函数不反悔任何值，没有函数类型也没有函数参数。由于没有函数参数所以不能被重载，一个类可以有多个构造函数，但只能有一个析构函数。

#include<iostream>
#include<string>
using namespace std;
class Student
    {public:
    Student(int ,string ,char );
    ~Student()
        {cout<<"destruction "<<endl;}

    void display()
{
    cout<<"num: "<<num<<endl;
    cout<<"name: "<<name<<endl;
    cout<<"***: "<<***<<endl;}
    private:

        int num;
        string name;
        char ***;
        };

Student::Student(int n,string nam,char s){
        num=n;
        name=nam;
        ***=s;
        cout<<"construct called "<<endl;}
int main()
{
Student stud1(10010,"wang_li",'f');
stud1.display();
Student stud2(10011,"zhang_jun",'m');
stud2.display();
return 0;
}

输出结果：
root@fengye:~/hello2# g++ f1.cc -o f1
root@fengye:~/hello2# ./f1
construct called
num: 10010
name: wang_li
***: f
construct called
num: 10011
name: zhang_jun
***: m
destruction
destruction

调用析构函数的顺序是：先构造的后析构，后构造的先析构。