精华内容
下载资源
问答
  • 一个类实例化一个对象称为单例模式

    一个类只实例化出一个对象称为单例模式

    #include <iostream>
    
    class SingleClass
    {
    public:
        static SingleClass* GetSingleClass()    //静态成员函数
        {
            if (Count > 0)
            //如果Count大于0,那么就调用new创建一个类指针,并且计数Count减1,否则返回NULL
            {
                Count--;
                return new SingleClass();
            }
            else
            {
                return NULL;
            }
        }
    private:
        SingleClass(){};
        static int Count;   //静态成员变量Count,不允许在类中初始化。定义为const则可以在这初始化,但是不可更改,不适合在这使用
    };
    
    int SingleClass::Count = 1; //Count的初始化,可以自己设置限制创建实例的个数
    
    int main()
    {
        SingleClass* test;  //只能通过定义类指针来创建类实例
        test = SingleClass::GetSingleClass();
        return 0;
    }

    #include <iostream>
    
    class SingleClass
    {
    public:
        static SingleClass* GetSingleClass()    //静态成员函数
        {
            if (pSinClass == NULL)
            //如果pSinClass为NULL,那么就调用new创建一个类指针,否则返回NULL
            {
                pSinClass = new SingleClass();
                return pSinClass;
            }
            else
            {
                return NULL;
            }
        }
    private:
        SingleClass(){};
        static SingleClass* pSinClass;   //静态成员变量pSinClass,不允许在类中初始化。定义为const则可以在这初始化,但是不可更改,不适合在这使用
    };
    
    SingleClass* SingleClass::pSinClass = NULL; //pSinClass的初始化
    
    int main()
    {
        SingleClass* test;  //只能通过定义类指针来创建类实例
        test = SingleClass::GetSingleClass();
        return 0;
    }



    展开全文
  • C++只能实例化一个对象

    千次阅读 2015-10-18 18:07:54
    # include # include using namespace std;1.创建class Student { public: static Student* Limit(); //静态成员函数 void display(); private: static Student *total; //静态数据成员指针
    # include <iostream>
    # include <string>
    using namespace std;

    1.创建类

    class Student
    {
    public:
        static Student* Limit();  //静态成员函数
        void display();
    private:
        static Student *total;    //静态数据成员指针
        Student(string ,int);
        string name;
        int age;
    };

    2.类外实现

    //初始化静态成员数据
    Student* Student::total = NULL;
    Student::Student(string nam = "0",int ag = 0)
    {
        name = nam;
        age = ag;
    }
    Student* Student::Limit()           //功能:只能通过此函数调用构造函数进行初始化,然后返回唯一对象地址
    {
    
                        //定义bool类型的b为了实现 total = new student();只运行一次, 
                        //大概过程:(要记住 "b是静态成员" )
                        // 1)主函数创建第一个对象
                        //   b = false(满足条件进入IF)-> b = true 执行创建对象语句->
                        //   return对象地址total
                        // 2)主函数创建第二个对象
                        //   b = true (不满足IF条件,不进入IF)不会创建新的对象,->return
                        //   对象地址total(total不变同变量b一个性质)
                        // 所以无论主函数怎样创建对象都是将第一次创建的对象的地址返回给主函数
    
       static bool b = false;   
        if (b == false)   
        {                               
            b = true;   
            total = new Student();   
        }   
        return total;
    }
    
    void Student::display()
    {
        cout<<"名字:"<<name<<"\n年龄:"<<age<<endl;
    }

    3.程序入口

    int main()
    {
        //Student m("ss",12);          //不可访问,构造函数为私有成员函数
        //m.display();
        Student* a = Student::Limit(); //只能通过调用公有的静态成员函数来创建对象,返回对象的存储地址
        a->display();
        Student* b = Student::Limit(); //不是创建新的对象而是将指针b指向原有对象(a指向的对象)
        b->display();
    }

    4.讲解
    根据上面这段代码,要想在程序中只许创建一个Student类对象,调用静态成员函数Limit()即可。
    例如:

    Student MyObj(“ss”,12); // 编译出错 - 因为构造函数是 private

    // 获得指向类对象指针的正确方法
    Student* pMyObj1 = Student::Limit();

    // 下面的语句不会创建新的类对象,它所创建的对象指针pMyObj2与上面创建的pMyObj1指针是一样的,
    // 也就是说pMyObj1和pMyObj2所指的对象是一样的

    Student* pMyObj2 = Student::Limit();

    /****************************************分割线(2015.10.19)*************************************/

    5.简化版(增强版)
    1.将类类型的指针是否为空作为判断条件
    2.解决销毁对象之后不能创建对象问题,设置析构函数将 total初始化为NULL;上面的那个程序对应将bool类型的值 true转为false ,false转为true
    3.解决拷贝构造函数创建对象的问题
    若主函数通过以下方式来实例化对象,会报错,拷贝构造函数为私有,不能访问

        Student c(*a);              /通过拷贝构造函数创建对象。这样会报错
        c.display();
    
    class Student
    {
    public:
        static Student* Limit(); 
        ~Student();             //   增加之处 
        void display();
    private:
        static Student *total;  
        Student(string ,int);
        Student(const Student &a());  // 3.增加之处
        string name;
        int age;
    };
    Student* Student::total = NULL;
    //   1.增加之处
    Student::~Student()
    {
        total = NULL;
    }
    Student::Student(string nam = "0",int ag = 0)
    {
        name = nam;
        age = ag;
    }
    Student* Student::Limit()   
        //    2.更改之处,改为用指针是否为空作为判断条件比上一个更好理解
        if (NULL == total)   
        {                               
            total = new Student();   
        }   
        return total;
    }
    
    void Student::display()
    {
        cout<<"名字:"<<name<<"\n年龄:"<<age<<endl;
    }

    PS:可以通过this指针来检验是否只能实例化一个对象

    void Student::display()
    {
        cout<<"名字:"<<name<<"\n年龄:"<<age<<endl;
        cout<<this<<endl;   //打印this指针
    }

    结果:

            名字:0
            年龄:0
            00419488
            名字:0
            年龄:0
            00419488

    主函数创建的“两个对象”存储地址是完全一致的,所以实质只实例化了一个对象

    展开全文
  • java实例化一个抽象对象

    千次阅读 2019-07-16 16:23:09
    不对啊,根据我的知识一个抽象不能直接实例化一个对象出来,面向对象期末考试的卷子还有专门一道让你改错的题,一般抽象直接实例化对象都是每年必考的错误点。那这个对象从哪实例化,国家分配的吗?先不管,结果...

    问题的起因

    今天学习接口,继承和多态这一部分,遇到一个练习题挺好玩的。题目要求,创建一个抽象类,然后去实例化一个抽象类的对象。

    不对啊,根据我的知识一个抽象类不能直接实例化一个对象出来,面向对象期末考试的卷子还有专门一道让你改错的题,一般抽象类直接实例化对象都是每年必考的错误点。那这个对象从哪实例化,国家分配的吗?先不管,结果随手一new就见error

    分析

    单身狗开始做梦,假如我已经有了对象,那到时候是不是可以跟着对象一起去见从未谋面的家长了呢?想到这流下了没有实力的泪水,等等,对啊,假如我有了一个已经实例化的对象,而这个对象又是继承自一个抽象类,实例化对象之前肯定会先实例化父类的,那不就可以实例化抽象类了。想到这马上放弃撩妹,开始撸代码

    代码

    只要想法想到了,代码其实很简单

    //创建一个抽象类,实例化一个抽象类的对象
    abstract class B  //创建抽象类B
    {
    	private String str;//私有成员变量str
    	
    	public B(String a)//抽象类的构造函数
    	{
    		System.out.println("父类的实例化");
    		this.str=a;
    		System.out.println(str);
    	}
    	
    	public abstract void play();//抽象类中的play()抽象方法
    
    }
    
    
    public class A extends B  //A类继承抽象类B
    {
    	public A(String a)//A的构造函数
    	{
    		super(a);
    		System.out.println("子类的实例化");
    	}
    	
    	@Override  //覆盖父类B中的play()
    	public void play()
    	{
    		System.out.println("重写抽象类中的play()方法");
    	}
    	
    	public static void main(String[] args)
    	{
    		B b=new A("小杰杰要加油啦"); //实例化抽象类对象
    	}
    }
    

    结果

    在这里插入图片描述
    单身狗也只能自己创建对象给自己加油了,继续去构造对象啦

    展开全文
  • 这道题的思路是,我只让这个通过一个公有函数实例化对象,即可以将构造函数设置为私有成员函数。include using namespace std;class Single { public: static Single& SingleCreate() { if (m == NULL) { m =...

    其实这是一道面试题。
    这道题的思路是,我只让这个类通过一个公有函数实例化对象,即可以将构造函数设置为私有成员函数。

    include <iostream>
    using namespace std;
    
    class Single
    {
    public:
    
        static Single& SingleCreate()
        {
            if (m == NULL)
            {
                m = new Single();
            }
                return *m;
        }
        ~Single()
        {
            delete m;
        }
    
        Single(const Single &a)
        {
        if (m == NULL)
        {
        m = new Single();
        }
        }
    
    private:
        Single()
        {}
        static  Single *m;
    };
    
    Single* Single::m = NULL;
    
    int main()
    {
        Single a = Single::SingleCreate();
    }

    这是我第一次写出的代码,我本来认为这样就可以了,结果经过我的调试,发现这样写是有问题的。
    这里写图片描述

    通过上面的图片可以看出,我们实例化的a的地址,跟在SingleCreate函数中返回的m的值是不同的,即这个类实例化了两个对象,这样就偏题了。
    经过分析,我们现在来看SingleCreate函数

        static Single& SingleCreate()
        {
            if (m == NULL)
            {
                m = new Single();
            }
                return *m;
        }

    这里retuen 的*m,会自动生成拷贝构造函数,因为return *m是返回一个对象,这里是返回临时变量,自动调用拷贝构造函数,因为我们没有定义拷贝构造函数,所以这里会自动生成一个拷贝构造函数。
    所以达不到只实例化一个对象的目的
    经过上面的分析,经代码优化为

    
    class Single
    {
    public:
    
    
        static Single* SingleCreatePtr()
        {
            if (m == NULL)
            {
                m = new Single();
            }
            return m;
        }
        ~Single()
        {
            delete m;
        }
    
    
    private:
        Single()
        {}
    
        static  Single *m;
    };
    Single* Single::m = NULL;
    int main()
    {
        Single *a = Single::SingleCreatePtr();
    }

    这个时候经过调试,得到下面
    这里写图片描述
    这个时候就得到的是一个对象。因为传指针的实质是在传地址,不会产生临时变量。
    现在已经解决了在返回值时只实例化一个对象的问题
    接下来看第三个问题
    三、构造函数
    接下来我们在main函数中加这么一句话:

    Single *b = a;

    这个时候会发生什么呢?
    对,会实例化出另一个对象,这是因为编译器自动生成了赋值构造函数,就像上面的拷贝构造函数一样,都是编译器自动生成并调用的,那么如何防止这些情况的发生?
    我的方法是在类中只声明不定义拷贝构造函数以及赋值构造函数。

    class Single
    {
    public:
    
        static Single& SingleCreate()
        {
            if (m == NULL)
            {
                m = new Single();
            }
                return *m;
        }
        static Single* SingleCreatePtr()
        {
            if (m == NULL)
            {
                m = new Single();
            }
            return m;
        }
        ~Single()
        {
            delete m;
        }
    
    
    private:
        Single()
        {}
        Single(const Single &a);
        Single& operator = (const Single &a);
        static  Single *m;
    };

    即将拷贝构造函数和赋值运算符重载函数都变成私有的成员函数,在外不可调用,就避免了因为构造函数多实例化对象的情况。
    四、通过静态局部变量

    class Single  
    {  
    private:  
        Single()   //构造函数是私有的  
        {  
        }  
    public:  
        static Single & GetInstance()  
        {  
            static Single instance;   //局部静态变量  
            return instance;  
        }  
    };  
    

    静态局部变量在GetInstance函数中被定义,初始化为0,且静态局部变量存放在内存的全局数据区。函数结束时,静态局部变量不会消失,每次该函数调用 时,也不会为其重新分配空间。它始终驻留在全局数据区,直到程序运行结束。静态局部变量的初始化与全局变量类似.如果不为其显式初始化,则C++自动为其 初始化为0。
    静态局部变量与全局变量共享全局数据区,但静态局部变量只在定义它的函数中可见。
    通过声明静态局部变量,但不进行初始化及赋值,那么编译器自动初始化为0,且永远不会改变,所以只会实例化一个对象。这个方法更加便捷高效。
    但是上面的代码没有考虑类拷贝的问题,大家参照上面的类拷贝问题可以自己把函数加上,然后去试一试,有问题可以留言大家一起解决~

    展开全文
  • 问题:不同的客户端去请求Servlet,该Servlet是同一个实例化对象还是不同的实例化对象?(即,是每次请求Servlet都会实例化一个该Servlet对象,还是每次请求都使用的是同一个Servlet对象?) 难道Servlet是单例模式吗?...
  • 在C++中,对象建立分为两种,一种是静态建立,如A a;... 静态建立一个类对象,是由编译器为对象在栈空间中分配内存,是通过直接移动栈顶指针,挪出适当的空间,然后在这片内存空间上调用构造函
  • 实现一个类只能实例化一次

    千次阅读 2016-07-30 17:30:19
    单例模式:达到只有一个实例 代码如下: class C{ private static $_instance; private function __construct(){ } public static function getInstance(){ if(!(self::$_instance instanceof self...
  • 设计一个只能创建一个唯一实例——单例模式 1. 背景  老师布置了一个思考题:设计一个只能创建一个唯一实例。让我们只要想一下思路即可。自己的第一反应就是设计模式中的单例模式。自己百度了一下单例...
  • 某个类只能有一个实例; 它必须自行创建这个实例; 它必须自行向整个系统提供这个实例。 从具体实现角度来说,就是以下三点: 单例模式的只提供私有的构造函数 定义中含有一个的静态私有对象提供了...
  • /// 这是私有的构造函数,说明只能在Atom实例化Atom的对象,也就是在静态构造函数中new出对象, /// 那么,其他地方要用Atom对象的话,就直接读上面那几Atom对象就OK,别去每用次Atom对象就new次 /// ...
  • 只能存在一个对象实例只能提供一个取得其对象实例的方法,只能产生一个 对象 单例模式的实现需要   public class Single { //声明一个静态的私有的引用变量,指向一个有对象 private static Single only...
  • 对象的抽象,对象的具体实例对象的另种名称。 2)、的定义 ①、成员属性(变量)的定义与使用 成员属性必须 var public protected private 语法: 形式1:var $v1 ; //定义不赋值 形式2:...
  • 详解Java对象实例化

    千次阅读 2015-11-06 11:44:08
    Java是一种面向对象的语言。由于具有面向对象特性的语言,Java支持以下基本概念: 多态性 继承 封装 抽象 对象 实例 方法 ... - 一个类可以被定义为描述行为的模板/蓝色印花/指
  • Java使用new和反射实例化内部类对象

    千次阅读 2017-03-07 16:09:25
    java使用new和反射实例化内部类对象 前两天看到一道面试题,是关于内部的知识,觉得很有意思,现对其详细讲解,绝对原创!~ 这道题是这样的: 根据注释填写(1),(2),(3)处的代码 public class Test{ public ...
  • 定义一个类只能创建一个对象

    千次阅读 2014-10-13 08:30:38
    有时我们的程序中需要定义一个类,这个类只能创建一个youxiaosh
  • 只能生成一个实例是实现了Singleton(单例)模式的类型。 解题思路:根据题目的要求,1.必须把构造函数设为私有函数,防止他人创建实例。 2.在中创建静态私有的实例,在需要时创建该实例,直到程序结束才销毁...
  • 1. 实例化对象   当定义好后,我们使用new关键字来生成一个对象。  $对象名称 = new 名称(); 示例:    class Person { //下面是人的成员属性 var $name; //人的名子 var $sex; ...
  • 基本概念这实例是子类的,但是因为你声明时是用父类声明的,所以你用正常的办法访问不到子类自己的成员,只能访问到从父类继承来的成员。在子类中用override重写父类中用virtual申明的虚方法时,实例化父类调用该...
  • 一是某个类只能有一个实例;二是它必须自行创建这个实例;三是它必须自行向整个系统提供这个实例。 从具体实现角度来说,就是以下三点:一是单例模式的只提供私有的构造函数,二是定义中含有一个的静态私有...
  • 请问 对象调用另一个类对象 是什么意思??? from flask_sqlalchemy import SQLAlchemy db = SQLAlchemy() class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key...
  • C++如何阻止一个类实例化

    千次阅读 2015-03-30 10:54:37
    (1)将定义为抽象基类或者将构造函数声明为private;  (2)不允许外部创建类对象只能内部创建对象
  • java里初始化一个类对象,通过初始快或者构造方法进行数据赋值。与其相关的执行代码这么几种: 静态初始块 初始块 构造方法 静态初始块 静态初始块只在加载时执行一次,同时静态初始只能给静态...
  • JavaScript 对象实例化

    千次阅读 2018-05-02 16:26:10
    参考资料:《JavaScript入门经典》利用内置对象创建直接实例JavaScript有一个内置对象Object,利用它可以创建一个空白的对象。aObject = new Object();添加属性这样,我们就创建了没有任何属性和方法的空白对象。...
  • Python-类对象方法和类实例对象方法

    千次阅读 2018-06-05 13:33:26
    自己总结python类对象方法和... (3)除了以上两条外,至少带一个参数的方法定义,且没有classmethod标识的,肯定为实例对象方法(第一个参数实际上是类实例对象self,比较隐含)。请大家分析如下代码:# -*- ...
  • 一个类就像是一个创建对象的模具。有些面向对象语言提供了的概念,在这些语言中每个对象都是某个特定实例。lua则没有的概念,每个对象只能自定义行为和形态。不过,要在lua中模拟也并不困难。 lua中,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 670,868
精华内容 268,347
关键字:

一个类只能有一个实例化对象吗