学习c++ 第六天 对象调用成员函数 new关键

如果想要调用成员函数，其实是有三种方法的：

1、设置成静态成员函数，可以直接通过类名调用 Class::fun();

2、创建一个对象 object，使用object.fun()方法调用;

3、创建一个匿名的对象，使用匿名对象调用 Class().fun();

对于公有的静态成员函数，可以通过类名来调用；而一般的非静态成员函数只能通过对象名来调用。

例：static void Afun(int n);

可以通过：

① aBox.Afun(10); //对象调用
②CBox::Afun(10); //类+作用域调用

c++创建一个对象的方法有两种，一种直接创建，如

(1)一种是ListNode p = ListNode(5);

(2)另一种是 ListNode p = new ListNode(5)

直接创建的对象存储在栈上，而使用new创建的对象保存在堆（操作系统）上。栈上的对象在函数执行后便将被删除，与保存在栈中的局部变量类似。而堆则需要自己手动释放存储空间。 顺便回顾下操作系统中堆与栈的区别：

1. 栈：编译器自行分配释放，一般保存的为局部变量，工作模型类似于数据结构中的栈。

2. 堆：程序员分配释放，分配方式类似于链表。 

下面是自己总结的一些关于new创建类对象特点：

1. new创建类对象需要指针接收，一处初始化，多处使用
2. new创建类对象使用完需delete销毁
3. new创建对象直接使用堆空间，而局部不用new定义类对象则使用栈空间
4. new对象指针用途广泛，比如作为函数返回值、函数参数等
5. 频繁调用场合并不适合new，就像new申请和释放内存一样

方式1
Ctest  pTest; //定义标识符pTest ，并在栈中申请空间
// 方式2
Ctest *pTest = new Ctest();//定义pTest ，并在堆中申请空间，过后需手动释放内存
delete pTest; // 使用delete 才会释放指针所指向的空间 释放时调用析构函数
// 方式2
Ctest mTest;  // 使用完后，该类的析构函数负责空间释放

#include 
using namespace std;

//类的声明
class Student{
private:  //私有的
    char *m_name;
    int m_age;
    float m_score;

public:  //共有的
    void setname(char *name);
    void setage(int age);
    void setscore(float score);
    void show();
};

//成员函数的定义
void Student::setname(char *name){
    m_name = name;
}
void Student::setage(int age){
    m_age = age;
}
void Student::setscore(float score){
    m_score = score;
}
void Student::show(){
    cout< setname("李华");
    pstu -> setage(16);
    pstu -> setscore(96);
    pstu -> show();

    return 0;
}

(1)

#include 
using namespace std;

class Student{
public:
    Student(char *name, int age, float score);
    void show();
public:  //声明静态成员函数
    static int getTotal();
    static float getPoints();
private:
    static int m_total;  //总人数
    static float m_points;  //总成绩
private:
    char *m_name;
    int m_age;
    float m_score;
};

int Student::m_total = 0;
float Student::m_points = 0.0;

Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){
    m_total++;
    m_points += score;
}
void Student::show(){
    cout< show();//实例化通过->非静态成员函数
    (new Student("李磊", 16, 80.5)) -> show();//实例化通过->非静态成员函数
    (new Student("张华", 16, 99.0)) -> show();//实例化通过->非静态成员函数
    (new Student("王康", 14, 60.8)) -> show();//实例化通过->非静态成员函数

    int total = Student::getTotal();//类名调用静态成员函数
    float points = Student::getPoints();
    cout<<"当前共有"<

(2)

#include "stdafx.h"
 #include 
 #include 
 
 
 class Num
 {
 private:
 int a;
         std::string objectName;
 public:
         Num(std::string objectName,int a);
 void showNum();
 };
 
 Num::Num(std::string objectName,int a)
 {
 this->objectName=objectName;
 this->a=a;
 }
 
 void Num::showNum()
 {
     std::cout<objectName<<":this="<

(2.1)

#include 
using namespace std;
class point
{
private:
    int h,m,s;
public:
    void show_time();//成员函数的声明
    void jude_h();//成员函数的声明
    void jude_m();//成员函数的声明
    void jude_s();//成员函数的声明
};

void point::jude_h()//成员函数的定义
{
    if(h<0)
    {
        h=0;
    }
    else if(h>12)
    {
        h=12;
    }
}
void point::jude_m()
{
    if(m<0||m>60)
    {
        m=0;
    }
}
void point::jude_s()
{
    if(s<0||s>60)
    {
        s=0;
    }
}
 void point::show_time()
 {
     if(h<10)
     {
         cout<<"0"<

(3)

#include "iostream"
using namespace std;
 
class A
{
public:
    A (int _a=0, int _b=0)
    {
        this->a1 = _a;
        this->b1 = _b;
        cout << "construct function called！" << endl;
    }
    A (A &obj)
    {
        cout << "copy_constructor function called!" << endl;
    }
    ~A()
    {
        cout << "objext destory function called!" << endl;
    }
    void printf()
    {
        cout << this->a1 << " " << this->b1 << endl;
 
    }
protected:
private:
    int a1;
    int b1;
};
 
int main()
{
    A(10, 10).printf();  //直接通过类名构造一个匿名对象，用后即焚
    cout << "在此处打印之前，匿名对象就已经被析构！" << endl;
    return 0;
}