精华内容
下载资源
问答
  • 在慕课网学习的封装 看着视频跟着老师敲代码...然后放到Line里作为 private 成员变量了———————————————————————— 下面是我自己敲的代码 总共有5个文件 首先是包含main函数的cpp文件#i

    在慕课网学习类的封装
    看着视频跟着老师敲代码感觉很简单
    关掉视频自己敲
    敲到一半发现敲不动;
    然后又反复的看了几遍视频
    最后知道了自己不会的原因
    这里写图片描述
    这是要求
    其实老师是
    实例化了两个坐标类的对象
    然后放到Line类里作为 private 成员变量了

    ————————————————————————
    下面是我自己敲的代码
    总共有5个文件
    首先是包含main函数的cpp文件

    #include "stdafx.h"
    #include<iostream>
    #include<cstdlib>
    #include"Line.h"
    using namespace std;
    
    
    int main()
    {
         Line *p = new Line;
         delete p;
    
        return 0;
    }

    其次是Line.h文件

    #pragma once
    #include"stdafx.h"
    #include"dian.h"
    
    class Line
    {
    public:
        Line();
        ~Line();
    
        void setA(int x, int y);
        void setB(int x, int y);
    
        void printInfo();
    
    
    private:
        dian A;      //类A的对象可以成为类B的数据成员
        dian B;
    };

    然后是line.cpp文件

    #include"stdafx.h"
    #include<iostream>
    #include"Line.h"
    using namespace std;
    
    Line::Line()
    {
        cout << "Line的构造函数被执行了" << endl;
    }
    Line::~Line()
    {
        cout << "Line的析构函数被执行了" << endl;
    }
    
    void Line::setA(int x, int y)
    {
        A.setX(x);
        A.setY(y);
    }
    void Line::setB(int x, int y)
    {
        B.setX(x);
        B.setY(y);
    
    }
    
    void Line::printInfo()
    {
        cout << "点A的坐标是:" << "(" <<A.getX() << "," << A.getY() << ")" << endl;
        cout << "点B的坐标是:" << "(" << B.getX() << "," << B.getY() << ")" << endl;
    }
    

    dian.h文件

    #pragma once
    #include"stdafx.h"
    
    class dian
    {
    public:
        dian();
        ~dian();
    
        void setX( int x);
        void setY( int y);
    
        int getX();
        int getY();
    
    
    private:
        int m_X;      //表示任意一个点的X坐标
        int m_Y;
    };
    
    

    dian.cpp文件

    #include"stdafx.h"
    #include<iostream>
    #include"dian.h"
    using namespace std;
    
    dian::dian() 
    {
        cout << "点的构造函数被执行了" << endl; 
    }
    dian::~dian()
    {
        cout << "点的析构函数被执行了" << endl;
    }
        void dian :: setX(int x)
        {
            m_X = x;
        }
        void dian::setY(int y)
        {
            m_Y = y;
        }
    
        int dian::getX()
        {
            return m_X;
        }
        int dian::getY()
        {
            return m_Y;
        }
    
    
    

    **

    实例化对象A时 ,如果对象A有对象成员B,那么先执行对象B的构造函数,在执行A的构造函数

    **

    展开全文
  • 类数据成员 C++中有一种类型成员,属于本身,而属于的对象,这种类型成员成为类成员,而属于对象的成员成为对象成员或实例成员。可以使用关键字static来创建一个成员。 static声明与定义 class C { public...

    类数据成员

    C++类中有一种类型成员,属于类本身,而不属于类的对象,这种类型成员成为类成员,而属于对象的成员成为对象成员实例成员。可以使用关键字static来创建一个类成员。

    static声明与定义

    class C
    {
    public:
        //...
    private:
        static unsigned n;
        //...
    };
    unsigned C::n=0; //在外部定义时不需要加static
    

    在类声明内部声明的static数据成员必须在任何程序块之外定义。通过外部定义将C::n初始化为0,但这不是必须的,因为在创建第一个对象时,所有的静态数据都会被初始化为零,除非提供一个不同的初值。并且在类体外定义的,不必使用static
    static数据成员不会影响该类及其对象的sizeof

    #include<iostream>
    using namespace std;
    class C
    {
    public:
        int a;
        unsigned long b;
        //...
    private:
        //static unsigned n1; //does not impact sizeof(C)
        //static unsigned n2; //does not impact sizeof(C)
        //...
    };
    int main()
    {
        cout<<sizeof(C)<<endl;
        C c1;
        cout<<sizeof(c1)<<endl;
        return 0;
    }
    

    类成员函数

    除了static数据成员,类还可以有static成员函数。静态成员函数只能访问其他的static成员,包括数据成员和成员函数。

    class C
    {
    public:
        static unsigned getN()
        {
            setST(); //ERROR:not static!
            return n;
        }
    private:
    	unsigned n;
    }
    

    静态成员函数与非静态成员函数差别是:非static成员函数既可以访问static数据成员,也可以访问非static数据成员;而static成员函数只能访问static成员。

    类的static成员的访问

    有两种不同方式来访问类的static成员,既可以通过C的对象来访问,也可以直接通过类C来访问。

    #include<iostream>
    using namespace std;
    class C
    {
    public:
        static void getN()
        {
            cout<<n<<endl;
        }
    private:
        static unsigned n;
    };
    unsigned C::n=10;
    int main()
    {
        C::getN(); //直接通过类C来访问
        C c1; 
        c1.getN(); //通过C的对象来访问
        return 0;
    }
    

    在类成员函数内定义static变量

    #include<iostream>
    using namespace std;
    class C
    {
    public:
        void m();
    private:
        static unsigned n;
    };
    unsigned C::n=100;
    void C::m()
    {
        static int s=0;
        cout<<"s="<<++s<<endl;
        cout<<"n="<<n++<<endl;
        cout<<endl;
    }
    int main()
    {
        C c1,c2; 
        c1.m(); 
        c2.m();
        c1.m();
        return 0;
    }
    

    输出结果:

    s=1
    n=100
    
    s=2
    n=101
    
    s=3
    n=102
    

    本例在成员函数m中定义了一个static变量s,由于s定义在程序块内,他拥有程序块范围,因为只能在m内部访问。每调用m一次,s就会相应的增加一次,又因为m是C的成员函数,所以C的所有对象都共享这个静态局部变量,这样,对m的每一次调用访问的都是同一个s,同样,对于静态局部变量n来说,它也是一个静态局部变量,所以C的所有对象也都共享这个局部变量。

    展开全文
  • C++中为什么中自身的对象能做自己的数据成员,但是做静态数据成员、引用类数据成员可以? student { private: student a;//错误! student *b;//正确! static student c;//正确! } 定义中...
     
    

    C++中为什么类中自身类的对象不能做自己的数据成员,但是做静态数据成员、引用类数据成员等可以?

    <pre name="code" class="cpp">student
    {  
       private:
           student     a;//错误!
           student     *b;//正确!
       static  student    c;//正确!
    }


     
    
    类定义中不能包含自己本身的对象,否则会引起像无限递归的问题,而静态成员属于类,而不属于对象,静态成员的作用域属于类,但不占类的大小,不属于类的对象,内存在全局存储区
    

    展开全文
  • C++静态数据成员静态成员函数 我们如何才能在范围内共享数据呢? 这个问题便是本章的重点: 声明为static的成员或者成员函数便能在的范围内共同享,我们把这样的成员称做静态成员和静态成员函数。 下面...
    把类中的函数都定义成静态函数,这样相当于在编译时就分配了空间,这样不需要实体对象也可以调用泪中的函数了。
    

    C++类静态数据成员与类静态成员函数

    我们如何才能在类范围内共享数据呢?

      这个问题便是本章的重点:

      声明为static的类成员或者成员函数便能在类的范围内共同享,我们把这样的成员称做静态成员和静态成员函数

      下面我们用几个实例来说明这个问题,类的成员需要保护,通常情况下为了不违背类的封装特性,我们是把类成员设置为protected(保护状态)的,但是我们为了简化代码,使要说明的问题更为直观,更容易理解,我们在此处都设置为public。

      以下程序我们来做一个模拟访问的例子,在程序中,每建立一个对象我们设置的类静态成员变自动加一,代码如下:

    #include <iostream
    using namespace std; 
     
    class Internet 

    public
        Internet(char *name,char *address) 
        { 
            strcpy(Internet::name,name); 
            strcpy(Internet::address,address); 
            count++; 
        } 
        static void Internet::Sc()//静态成员函数,静态函数必须在类体内实现 
        { 
            cout<<count<<endl; 
        } 
        Internet &Rq(); 
    public
        char name[20]; 
        char address[20]; 
        static int count;//这里如果写成static int count=0;就是错误的 
    }; 
     
    Internet& Internet::Rq()//返回引用的成员函数 

        return *this

     
    int Internet::count = 0;//静态成员的初始化 
    void vist() 

        Internet a1("中国软件开发实验室","www.cndev-lab.com"); 
        Internet a2("中国软件开发实验室","www.cndev-lab.com"); 

    void fn(Internet &s) 

        cout<<s.Rq().count

    void main() 

        cout<<Internet::count<<endl;//静态成员值的输出 
        vist(); 
        Internet::Sc();//静态成员函数的调用 
        Internet b("中国软件开发实验室","www.cndev-lab.com"); 
        Internet::Sc(); 
        fn(b); 
        cin.get(); 
    }

       上面代码我们用了几种常用的方式建立对象,当建立新对象并调用其构造函数的时候,静态成员cout便运行加1操作,静态成员的初始化应该在主函数调用之 前,并且不能在类的声明中出现,通过运行过程的观察我们发现,静态成员count的状态并不会随着一个新的对象的新建而重新定义,尽而我们了解到类的静态成员是属于类的而不是属于哪一个对象的,所以静态成员的使用应该是类名称加域区分符加成员名称的,在上面的代码中就是Internet::count,虽然我们仍然可以使用对象名加点操作符号加成员名称的方式使用,但是不推荐的,静态态类成员的特性就是属于类而不专属于某一个对象。

    静态成员函数的特性类似于静态成员的使用,同样与对象无关,调用方法为类名称加域区分符加成员函数名称,在上面的代码中就是Internet::Sc();,静态成员函数由于与对象无关系,所以在其中是不能对类的普通成员进行直接操作的

      如果上面的 static void Internet::Sc()修改成为:

    static void Internet::Sc()//静态成员函数 

        cout<<name<<endl;//错误 
        cout<<count<<endl; 
    }

      静态成员函数与普通成员函数的差别就在于缺少this指针,没有这个this指针自然也就无从知道name是哪一个对象的成员了。

      根据类静态成员的特性我们可以简单归纳出几点,静态成员的使用范围:

      1.用来保存对象的个数。

      2.作为一个标记,标记一些动作是否发生,比如:文件的打开状态,打印机的使用状态,等等。

      3.存储链表的第一个或者最后一个成员的内存地址。

      为了做一些必要的练习,深入的掌握静态对象的存在的意义,我们以前面的结构体的教程为基础,用类的方式描述一个线性链表,用于存储若干学生的姓名,代码如下:

    #include <iostream
    using namespace std; 
     
    class Student 

    public
        Student (char *name); 
        ~Student(); 
    public
        char name[30]; 
        Student *next; 
        static Student *point; 
    }; 
     
    Student::Student (char *name) 

        strcpy(Student::name,name); 
        this->next=point; 
        point=this

     
    Student::~Student ()//析构过程就是节点的脱离过程 

        cout<<"析构:"<<name<<endl; 
     
        if(point==this
        { 
            point=this->next; 
            cin.get(); 
            return
        } 
        for(Student *ps=point;ps;ps=ps->next) 
        { 
            if(ps->next==this
            { 
            cout<<ps->next<<"|"<<this->next<<endl; 
            ps->next=next;//=next也可以写成this->next; 
            cin.get(); 
            return
            } 
        } 
        cin.get(); 

     
    Student* Student::point=NULL; 
    void main() 

        Student *c = new Student("marry"); 
        Student a("colin"); 
        Student b("jamesji"); 
        delete c; 
        Student *fp=Student::point; 
        while(fp!=NULL) 
        { 
            cout<<fp->name<<endl; 
            fp=fp->next; 
        } 
        cin.get(); 
    }

      从上面的代码来看,原来单纯结构化编程需要的一个链表进入全局指针在这里被类的静态成员指针所替代(类的静态成员完全可以替代全局变量),这个例子的理解重点主要是要注意观察类成员的析构顺序,通过对析构顺序的理解,使用析构函数来进行节点的脱链操作。

    展开全文
  • C++的常数据成员和常成员函数

    千次阅读 2019-03-11 11:01:07
    能采用在构造函数中对常数据成员进行赋初值的方法,因为常数据成员能被赋值的。 构造函数只能用参数初始化列表对常数据成员进行初始化 Time ::Time (int h):hour(h){}//通过参数初始化表对常数据成员进行...
  • 众所周知,的私有变量是无法在外直接访问的,只能通过成员函数访问。 且看下面一段代码: class Stock { private: double total_val;//这是私有的哦~ public: Stock();//默认构造函数 Stock(const ...
  • 数据结构:八大数据结构分类

    万次阅读 多人点赞 2018-09-05 18:23:28
    数据结构分类 数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中...数组是可以再内存中连续存储多个元素的结构,在内存中的分配也是连续的,数组中的元素通过数组下标进行访问,数组下标从0开始...
  • 允许 dllimport 静态数据成员

    万次阅读 2014-10-07 17:28:52
    允许 dllimport 静态数据成员 View Code 当要使用一个的时候必须要有其定义,有2种方式: 1、引用其头文件,即#include "xxx.h"。这是传统的方式。 2、使用导出。 什么是‘导出’,很...
  •  一个的私有数据成员通常只能由的函数成员来访问,而友元函数可以访问的私有数据成员,也能访问其保护成员 2. 友元函数的用处体现在哪里?  2.1 使用友元函数可提高性能,如:用友元函数重载操作符和生成迭代...
  • 静态数据成员

    千次阅读 2011-08-25 10:12:01
    静态成员包括静态数据成员和静态函数成员两部分。  ... 体中的数据成员的声明前加上static关键字,该数据成员成为了该的静态数据成员。和其他数据成员一样,静态数据成员也遵守public/pr
  • 成员变量称为数据成员它们是类中变量。  成员变量也叫数据成员,他们是类中的变量。成员变量是类的组成部分 。类还可以包含函数,它们被称为成员函数或者方法。成员函数和成员变量一样,是类的重要组成部分,它们...
  • class X { }; class Y : public virtual X { }; class Z : public virtual X ...定义上面的X,Y,Z分别虚拟公有继承X,A继承Y,Z。那么sizeof(X)、sizeof(Y)、sizeof(Z)、sizeof(A)分别为多
  •  一个的私有数据成员通常只能由的函数成员来访问,而友元函数可以访问的私有数据成员,也能访问其保护成员 2. 友元函数的用处体现在哪里?  2.1 使用友元函数可提高性能,如:用友元函数重载操作符和生成...
  • static数据成员与static成员函数

    千次阅读 2013-05-13 11:51:45
    每个只有一个存储单元,静态数据成员为该的所有对象共有,属于某个对象。静态数据成员的初始化必须在以外进行定义性说明。 形式为:类型> 类名>::静态数据成员> =值 静态成员注意以下几点: 1、静态...
  • c++static数据成员和成员函数

    千次阅读 2012-07-17 16:26:53
    Static数据成员定义时就存在了,所以有不同于一般数据成员的特性 ...所以static数据成员定义应该放在头文件中,应该放在非内联函数定义地方 xxx.h文件  class base{  private:  st
  • 定义一个teacher(教师)和一个student(学生),二者有一份数据成员是相同的,例如num,name,sex。编写程序,将一个student对象(学生)转换为teacher(教师),只将以上3个相同的数据成员移植过去。可以设想...
  • C++ 语言的私有成员

    千次阅读 2020-02-24 15:39:47
    构造函数是为对象的数据成员赋值的。 在定义成员时使用关键字 private,可以得到所需的安全性。通常情况下,私有成员只能被的成员函数访问,有一种情况例外。普通的函数没有访问私有成员的直接途径。 ...
  • C++的静态数据成员

    千次阅读 2008-04-21 18:11:00
     一 静态数据成员: 体中的数据成员的声明前加上static关键字,该数据成员成为了该的静态数据成员。和其他数据成员一样,静态数据成员也遵守public/protected/private访问规则。同时,静态数据成员还具有...
  • 定义一个teacher(教师)和一个student(学生),二者有一份数据成员是相同的,例如num,name,sex。编写程序,将一个student对象(学生)转换为teacher(教师),只将以上3个相同的数据成员移植过去。可以设想...
  • 为什么你成为不了团队核心成员

    万次阅读 2020-10-19 06:47:00
    一、背景之前我讲过一个《业务重要?还是技术重要?》,后来收到评论恢复,工作3年以上的同事大多认为业务和技术同等重要。作为一个数据人,我一直想讲业务比数据更重要,但一直怕遭到热衷技术同学的...
  • c++成员变量和成员函数详解

    千次阅读 2019-04-09 14:38:18
    类可以看做是一种数据类型,它类似于普通的数据类型,但是又有别于普通的数据类型,这种类型是一个包含成员变量和成员函数的集合。 成员变量和普通变量一样,也有数据类型和名称,占用固定长度的内存。但是,...
  • 一个对象它属于引用类型数据实例,当然就可以出现在一个中作为这个成员使用了,可能这个对象不是这个的特有 特征,但是它们存在一些必然或者实际行为动作中产生的间接联系,一个对象成为一个成员也就...
  • C++静态数据成员定义及应用浅谈

    千次阅读 2012-08-24 14:23:10
    类体中的数据成员的声明前加上static关键字,该数据成员成为了该类的静态...静态数据成员实际上是类域中的全局变量。所以,静态数据成员的定义(初始化)应该被放在头文件中。 其定义方式与全局变量相同。举例如下
  • 静态类成员包括静态数据成员和静态函数成员两部分。 一、 静态数据成员:  类体中的数据成员的声明前加上static关键字,该数据成员成为了该类的静态数据...静态数据成员实际上是类域中的全局变量。所以,静态

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 286,418
精华内容 114,567
关键字:

不可以成为类的数据成员的是