C++学习笔记_three_day

C++ 类----- 一种数据类型

-------class

属性：--------类 内部的数据

行为：--------类 内部的函数

类的变量 ------对象

类（种类） ------对象

描述事物（学生）  具体的事物（吴尚奇）     如：

 

//cat.cc
#include<string.h>

#include<iostream>
using namespace std;

//猫类
class Cat
{
//属性
    char m_name[20];  //名子 //m->member成员

public://访问修饰符，  - 控制类 内部成员的访问权限

//行为
    //取名子
    void Setname(const char *name)
    {
        strcpy(m_name,name);
        return;
    }
    //吃食物
    void eat()
    {
        cout<<m_name<<" 吃鱼 "<<endl;
    }
};

int main(int argc,char **argv)
{
    Cat cat;//创建了一个cat对象
    cat.Setname("Jinshan");
    cat.eat();

    return 0;
}

 

2.访问修饰符， - 控制类 内部成员的访问权限

作用是：限制类 内部成员（数据和函数）的访问（调用）

public：共有的访问修饰符

让成员在任何地方使用

Struct 的默认访问权限是public

Class 的默认访问权限是 private

protected： 受保护的访问修饰符

private：私有的访问修饰符

Protected、private只能在类的内部使用

Class A{ |<--------类的内部------->| };

通过访问修饰符 将 类 内部的重要数据进行隐藏

类的性质：

隐藏：通过访问修饰符 将 类 内部的重要数据进行隐藏

封装：将数据和函数绑定成一个逻辑单元

私有成员的访问：

一般使用共有的函数进行访问

Set（）/Get（）人为定义的

 

//process.cc
#include<iostream>
using namespace std;

class Test
{
public:
    int m_a1;  //若上面没有public则默认m_a1是private修饰
protected:
    int m_a2;
private:
    int m_a3;

public:
    void value(int a1, int a2, int a3)
    {
        m_a1=a1;
        m_a2=a2;
        m_a3=a3;
    }
    void show()        //m_a2和m_a3只能在类 的内部访问，在主函数里面是访问不到的
    {
         cout<<" m_a2="<<m_a2<<" m_a3="<<m_a3<<endl;
         return;
    }
};

int main()
{
    Test t1;
    t1.value(2,3,4);

    cout<<" m_a1="<<t1.m_a1<<endl;
    cout<<"**********************"<<endl;
    t1.show();

    return 0;
}

 

私有成员的访问：

一般使用共有的函数进行访问

set()/get() 人为定义的

//Set_get.cc
#include<string.h>

#include<iostream>
using namespace std;

class Gir1
{
    char m_name[20]; //默认是private的
public:
    //设置 m_name的值
    void Setname(const char *name )
    {
        strcpy(m_name,name);
        return;
    }

    //获得m_name 的 值
    char  *Getname()
    {
        return m_name;
    }
};

int main(int argc, char **argv)
{
    //这里的Setname()和Getname()是人为规定的对类内部私有数据访问的合法途径
    Gir1 g1;
    g1.Setname("颜栏栏");
    
    cout<<"女孩子的名子是 "<<g1.Getname()<<endl;

    return 0;
}

作业：struct和class的区别：

　　解答：

class是引用类型，struct是值类型；

class可以继承类、接口和被继承，struct只能继承接口，不能被继承；

class有默认的无参构造函数，有析构函数，struct没有默认的无参构造函数，且只能声明有参的构造函数，没有析构函数；

class可以使用abstract和sealed，有protected修饰符，struct不可以用abstract和sealed，没有protected修饰符；

class必须使用new初始化，结构可以不用new初始化；

class实例由垃圾回收机制来保证内存的回收处理，而struct变量使用完后立即自动解除内存分配；

从职能观点来看，class表现为行为，而struct常用于存储数据；

作为参数传递时，class变量以按址方式传递，而struct变量是以按值方式传递的。

如何选择使用结构还是类：

1）．堆栈的空间有限，对于大量的逻辑的对象，创建类要比创建结构好一些

2）．结构表示如点、矩形和颜色这样的轻量对象，例如，如果声明一个含有 1000 个点对象的数组，则将为引用每个对象分配附加的内存。在此情况下，结构的成本较低

3）．在表现抽象和多级别的对象层次时，类是最好的选择

4）大多数情况下该类型只是一些数据时，结构是最佳的选择。

2. 构造函数和析构函数

类里面的成员函数

没有的时候，系统默认提供

构造函数：初始化类的成员数据 constructor

析构函数：释放内存空间

　　析构函数在一定意义上可以看作是构造函数的逆操作

 

//coustructor.cc
#include<iostream>
using namespace std;

class A
{
    //构造函数
    //1、没有返回值
    //2、函数名就是类名
    //3、在创建一个对象的时候，会自动调用
    int m_i;
    double m_d;
public:
    //允许重载函数/可以带参数
    //功能：
    //  （1）给成员数据分配内存空间
    //  （2）初始化成员数据
    A()
    {
        cout<<" wushangqi"<<endl;
    }

    //可以带参数的
    A(int i, double d)
    {
        m_i=i;
        m_d=d;
        cout<<" A() "<<endl;
    }

    void show()
    {
        cout<<" m_i= "<<m_i<<endl;
        cout<<" m_d= "<<m_d<<endl;
    }
};  //don't forget me -> ;

int main(int argc, char **argv)
{
    //通过参数列表将实参传给构造函数的形参
    A a(10,3.14);//创建了一个对象a 根据函数的参数自动匹配
    a.show();
    return 0;
}

 

析构函数：

//disconstructor.cc
#include<iostream>
using namespace std;

class A
{
    //析构函数
    //1、没有返回值
    //2、函数名和类名相同
    //3、用 ～ 修饰函数
    //4、不带参数的
public:
    //在对象消亡的时候，会自动调用
    ~A()
    {
        cout<<" ~A() "<<endl;
    }
        
};

int main(int argc, char **argv)
{
    A a;
    cout<<"~~~~~~~~~~~~~飘过~~~~~~~~~~~"<<endl;

    return 0;//在函数结束的时候消亡,这个时候自动调用析构函数
}

作业2：

　　析构函数和构造函数可以手动调用吗？（重要）

解答：

构造函数是不能手动调用的。

析构函数可以手动调用。逻辑上是错误的。

C++中, 构造函数和析构函数可以被显示调用. 显示调用默认构造函数的语法: a.A::A();(不能写成a.A();) , 显示调用非默认构造函数的语法: a.A::A(7);(不能写成a.A(7);); 显示调用析构函数的语法: a.A::~A();(可以写成a.~A();) .

显示调用构造函数和析构函数就像调用一般的函数一样, 并不意味着创建或销毁对象;

如果构造函数中动态分配了空间, 则显示调用构造函数会造成内存泄露. 创建对象时的隐式构造函数调用已经为对象分配了动态内存. 当用创建好的对象显示调用构造函数时, 对象指向的动态内存更新显示调用时所分配的, 对象生命周期结束时析构函数所释放掉的是后一次分配的动态内存, 也就是说创建对象时隐式构造函数调用所分配的那块内存泄漏了.

如果析构函数中释放动态分配的空间, 则会造成多次释放同一内存, 会出现严重错误.

 

 

 

隐含成员

 

当一个类没有写 构造函数 和 析构函数 的时候 系统会自动提供构造函数和析构函数，一旦程序写了构造函数和析构函数，系统就不会再提供默认的 构造函数和 析构函数

 

构造函数 和 手写函数即使不作任何操作，仍然需要手写，为了 提高调用的速度

 

类的隐藏成员

 

构造函数 和 析构函数

this指针，指向对象的地址

 

//this.cc
#include<iostream>
using namespace std;

class A
{
public:
    void Addr()
    {
        //this 当前对象的地址
        cout<<" this = "<<this<<endl;
    }
};

int main(int argc, char **argv)
{
    A a1;
    A a2;

    cout<<endl;
    cout<<" 打印a1的地址:"<<endl;
    cout<<" &a1 = "<<&a1<<endl; 
    a1.Addr();
    
    cout<<"---------------------------"<<endl;
    
    cout<<" 打印a2的地址:"<<endl;
    cout<<" &a2 = "<<&a2<<endl; 
    a2.Addr();

    return 0;
}

 

/*练习1：
设计一个分数类：
    一个分数包含分子和分母
    （1）设置分数的值
    （2）可以按格式打印
            12,13   12/13
    （3）可以约分（注意+/-符号的处理）
            12,-16        -3/4
*/
  //Fract.cc
#include <iostream>
using namespace std;

/**
* Fraction
**/
class Fract
{
    int m_n; // 分子
    int m_d; // 分母
public:
    Fract(int n,int d);
    ~Fract(){}

    void print();  // 打印分数
    void reduc();  // 约分
};

Fract::Fract(int n,int d)
{
    m_n = n;
    m_d = d;    
}

// 打印分数
void Fract::print()
{
    cout << m_n << "/" << m_d << endl;
    return ;
}

// 约分
void Fract::reduc()
{
    // 处理+/-符号问题
    if( m_d < 0)
    {
        m_d = -m_d;
        m_n = -m_n;
    }

    // 找最大公约数
    int i;
    for(i = m_d; i > 1 ; --i)
    {
        if( (m_n%i == 0) && (m_d%i == 0))
        {
            m_n /= i;
            m_d /= i;
            break;
        }
    }
    
    return ;
} 


int main(int argc,char **argv)
{
    Fract f(-12,16);
    f.reduc();
    f.print(); //  -3/4
    return 0;
}

/*练习2：
设计一个日期类
    日期包含 年/月/日
    （1）可以设置日期    
    （2）判断闰年
    （3）输出 当前日期 是 该年的第几天
            2014/4/26  -> 2014年的第？天
*/
          //Data.cc
#include <iostream>
using namespace std;

static int arrday[12] = {31,28,31,30,31,30,31,31,30,31,30,31};

/**
* 日期类
*/
class Date
{
    int m_year;   // 年
    int m_month;  // 月
    int m_day;    // 日
public:
    Date(int year,int month,int day);
    ~Date(){}

    // 获得年份
    int GetYear(){ return m_year;}

    void show();        // 显示日期
    bool isLeapYear();  // 判断是否为闰年
    int DayofYear();    // 今年的第几天
    
};

Date::Date(int year,int month,int day)
{
    m_year = year;
    m_month = month;
    m_day = day;
}

// 1.显示日期
void Date::show()
{
    cout << m_year << "/"
         << m_month << "/"
         << m_day << endl;
    return ;
}

// 2.判断是否为闰年
bool Date::isLeapYear()
{
    return ( (m_year%4 == 0) && (m_year%100 != 0) ) || (m_year%400 == 0);
}

// 2014/4/26
// 计算前3个月的天数 + m_day

// 3.今年的第几天
int Date::DayofYear()
{
    int sum = 0;

    //1.计算m_month之前几个月的天数之和
    int i;
    for(i=0; i< m_month - 1; ++i)
    {
        sum += arrday[i];
    }

    //2.加上m_month本月的天数
    sum += m_day;

    //3.二月问题处理
    if( m_month > 2)
        sum += isLeapYear();

    return sum;
} 

int main(int argc,char **argv)
{
    Date d(2000,4,26);
    d.show();

    cout << d.GetYear() << " 是闰年吗？ "
         << (d.isLeapYear()?"是":"不是")
         << endl;

    cout << "是今年的第 " 
         << d.DayofYear()
         << " 天"  << endl;
    
    return 0;
}

1、局部对象的构造和析构的顺序

最先构造的对象，最后析构

数据存放栈区，先进后出

全局对象/局部对象/静态对象

Class A{};

A a1;//全局

Void fn()

{

A a3;

Static A a4;

}

Int main()

{

A a2;

Fn();

A a5;

Return 0;

}

请问这些对象的构造和析构顺序？？？？？？？？？？？？

2. C++是如何操作堆空间的

　　　　C语言 malloc() free()

　　　　C++语言 new delete 运算符

 //memory.cc

#include<iostream>

using namespace std;

int main(int argc, char **argv)

{

//这里的new和delete是运算符，不是函数

int *pi= new int ;//申请堆空间

*pi = 10;

cout<<" *pi="<<*pi<<endl;

delete pi;//释放堆空间

return 0;

}

 

作业：

Malloc/free与new/delete的区别

从面向对象来说，new/delete和malloc/free的区别是：malloc/free只是单纯的进行内存空间的分配和释放，而使用new/delete时，不仅分配了内存空间，若new/delete的是一个类，还会调用类（经测试，基本类型好像不会进行默认初始化）的构造函数或析构函数。

简单来说，两者的区别主要有：

1. malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符，与"+“、”-“、”*“、”/“有一样的地位。

2. new/delete是可以重载的，而重载之后，就成为了函数。

3. malloc在申请内存的时候，必须要提供申请的长度，而且返回的指针是void*型，必须要强转成需要的类型。

4. 当new/delete在类中被重载的时候，可以自定义申请过程，比如记录所申请内存的总长度，以及跟踪每个对象的指针。

5. new/delete，其实内部也调用了malloc/free。

两者的共同点有：

1. 都必须配对使用，防止内存泄露。

2. 都可用于申请动态内存和释放内存，都是在堆中分配内存。

3. free和delete可以释放NULL指针。

注意点：

不建议将new/delete与malloc/free混合使用：将new和delete或malloc和free混合使用並不是好主意。當你企圖對著一个「因new而得的指標」呼叫free時，或是對著一個「因malloc而得的指標」呼叫delete時，其結果都未有定義。而我們都知道所謂「未有定義」的意思就是：它在開發階段沒問題，它在測試階段沒問題，但是它會在你最重要的客戶面前突然爆發。

2. 初始化列表

功能：初始化类的成员数据

 //init_list.cc

#include<iostream>

using namespace std;

class A

{

int m_data;

int m_data2;

public:

A(int data,int data2):m_data(data),m_data2(data2)//使用初始化列表初始化成员数据

{

//使用初始化列表的时候，初始化成员变量并赋值

//调用构造函数的时候

 

//m_data=data; m_data2=data2;

//调用构造函数的时候

//第一步：定义成员数据（分配空间）

//第二布：执行构造函数体内的语句

cout<<m_data<<endl;

cout<<m_data2<<endl;

}

~A()

{

 

}

};

int main(int argc,char **argv)

{

A a(10,13);

return 0;

}

 

2. 拷贝构造函数(重新整理)

调用：用一个对象初始化另外一个对象的时候

 //copy_construct.cc

#include<iostream>

using namespace std;

class A

{

int m_data;

public:

A(int data):m_data(data)

{

cout<<"A()"<<endl;

}

~A()

{

cout<<"~A()"<<endl;

}

void show()

{

cout<<" m_data = "<<m_data<<endl;

return;

}

};

int main()

{

A a1(10);

//用a1初始化a2

A a2(a1);

a2.show();

A a3=a1;//用a1初始化a3

a3.show();

return 0;

}

 

浅拷贝----带用系统默认的拷贝构造函数 只拷贝数据的值

危害：在有指针变量的时候，它只能拷贝一个地址，一旦其中的某个对象将申请的空间释放，其他对象的指针成员都没有值了。一般只允许在不进行内存空间的情况下可用。

深拷贝----调用自己写的拷贝函数

在有指针成员变量的时候，直接在拷贝构造函数中为改指针成员申请空间

String 类----处理字符串的

 

　　　　--by   吴尚奇    Dervil_box    2014/05