精华内容
下载资源
问答
  • C++---全局对象、局部对象、静态对象
    千次阅读
    2018-11-27 21:53:16

    1、全局对象,程序一开始,其构造函数就先被执行(比程序进入点更早);程序即将结束前其析构函数将被执行。

    2、局部对象,当对象生成时,其构造函数被执行;当程序流程将离开该对象的声明周期时,其析构函数被执行。

    3 、静态(static)对象,当对象生成时其构造函数被执行;当程序将结束时其析构函数才被执行,但比全局对象的析构函数早一步执行。

    4、以new方式产生出来的局部对象,当对象生成时其构造函数被执行,析构函数则在对象被delete时执行时执行

    静态全局对象和一般的全局对象的区别就是一般的全局对象在程序的其他文件中可以通过关键字extern来调用,而static声明的全局变量则只能在本文件中使用,这是链接性一个是外部的,一个是内部的!
    四种不同对象生存方式(in stack、in heap、global、local static)
    在C++中,有四种方法可以产生一个对象。
    第一种方法是在堆栈(stack)之中产生:
    第二种方法是在堆(heap)中产生:
    第三种方法是产生一个全局对象
    第四种方法是产生一个局部静态对象

    class Test
    {
    public:
    	Test(int a, int b)
    	{
    		std::cout << this << "Test:: Test(int,int)" << std::endl;
    		ma = a;
    		mb = b;
    	}
    	Test(int a)
    	{
    		std::cout << this << "Test:: Test(int)" << std::endl;
    		ma = a;
    	}
    	Test()
    	{
    		std::cout << this << "Test:: Test()" << std::endl;
    	}
    	Test(const Test& rhs)
    	{
    		std::cout << this << "Test:: Test(const Test&)" << std::endl;
    		ma = rhs.ma;
    		mb = rhs.mb;
    	}
    	Test& operator=(const Test& rhs)
    	{
    		std::cout << this << "Test::operator = (const Test&)" << std::endl;
    		if (this != &rhs)
    		{
    			ma = rhs.ma;
    			mb = rhs.mb;
    		}
    		return *this;
    	}
    	~Test()
    	{
    		std::cout << this << "Test::~Test()" << std::endl;
    	}
    	int getValue()
    	{
    		return ma;
    	}
    private:
    	int ma;
    	int mb;
    };
    Test gtest1(10, 20);// 声明一个全局对象,global
    int main()
    {
    	Test test2;// 声明一个局部对象,在堆栈(stack)之中
    	static Test test3(10, 20);// 声明一个静态局部对象,local static
    	Test* ptest4 = new Test(10, 20);//动态生成的局部对象,在堆(heap)中
    	delete ptest4;
    	return 0;
    }
    
    更多相关内容
  • Java静态对象和非静态对象有什么区别?? 对于静态方法,相信它的作用在各位朋友眼里也是不容置疑的,那么他跟非静态到底有什么区别呢??? 到底有什么好处呢??对于静态方法来说~

    Java

    静态对象和非静态对象有什么区别?? 

       对于静态方法,相信它的作用在各位朋友眼里也是不容置疑的,那么他跟非静态到底有什么区别呢???


    (1)Java静态对象和非静态对象有什么区别?


         静态对象      
        是类共同拥有的           
       内存空间上是固定的    
      先分配静态对象的空间   


         非静态对象    

      是类各对象独立拥有的
      空间在各个附属类里面分配
      继而再对非静态对象分配空间,也就是初始化顺序是先静态再非静态.


    java静态对象到底有什么好处?


    A,静态对象的数据在全局是唯一的,一改都改。如果你想要处理的东西是整个程序中唯一的,弄成静态是个好方法。 非静态的东西你修改以后只是修改了他自己的数据,但是不会影响其他同类对象的数据。 
    B,引用方便。直接用 类名.静态方法名  或者  类名.静态变量名就可引用并且直接可以修改其属性值,不用get和set方法。
    C,保持数据的唯一性。此数据全局都是唯一的,修改他的任何一处地方,在程序所有使用到的地方都将会体现到这些数据的修改。有效减少多余的浪费。

    D,static final用来修饰成员变量和成员方法,可简单理解为“全局常量”。对于变量,表示一旦给值就不可修改;对于方法,表示不可覆盖。


    (2)静态变量、静态方法和静态块


           通常情况下,类成员必须通过它的类的对象访问,但是可以创建这样一个成员,它能够被它自己使用,而不必引用特定的实例。在成员的声明前面加上关键字static就能创建这样的成员。如果一个成员被声明为static,它就能够在它的类的任何对象创建之前被访问,而不必引用任何对象(跟类是否有static修饰无关)。


           你可以将方法和变量都声明为static。static 成员的最常见的 例子是main( ) 。声明为static的方法有以下几条限制(main也是??):  ·

    A,它们仅能调用其他的static 方法

    B,它们只能访问static数据

    C,它们不能以任何方式引用this 或super(this涉及到对象,super 与继承有关)


           示例:Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法,一些static变量,以及一个static 初始化块。

        public class TestNew {  
            static int a = 3;  
            static int b;  
            static void meth(int x){  
                System.out.println("x = "+x);  
                System.out.println("a = "+a);  
                System.out.println("b = "+b);  
            }  
            static {  
                System.out.println("static block initialized");  
                b = a*4;  
            }  
            public static void main(String[] args) {  
                // TODO Auto-generated method stub  
                meth(42);  
            }  
        }  

      执行结果是:

    static block initialized
    x = 42
    a = 3
    b = 12

    上述class TestNew的执行顺序是:首先static 块执行(打印一条消息),a被设置为3,最后b被初始化为a*4 成12。然后调用main(),main () 调用meth() ,把值42传递给x。3个println ( ) 语句引用两个static变量a和b,以及局部变量x 。


    (3)外部使用静态变量或者静态方法


           在定义它们的类的外面,static 方法和变量能独立于任何对象而被使用,你只要在类的名字后面加点号运算符即可。可以看到,这种格式与通过对象引用变量调用非static方法或者变量的格式类似。示例:


     class StaticDemo{  
            static int a = 42;  
            static int b = 99;  
            static void callme(){  
                System.out.println("a = "+a);  
            }  
        }  
        public class TestNew {  
            public static void main(String[] args) {  
                // TODO Auto-generated method stub  
                StaticDemo.callme();  
                System.out.println("b = "+StaticDemo.b);  
            }  
        } 

    执行结果:

    a = 42
    b = 99


    希望对您有帮助

    美好的绝对不是结束

    才刚刚开始~

    展开全文
  • 所有的静态对象、全局对象都于静态存储区分配。关于全局对象,是在main()函数执行前就分配好了的。其实,在main()函数中的显示代码执行之前,会调用一个由编译器生成的_main()函数,而_main()函数会进行所有全局对象...

    所有的静态对象、全局对象都于静态存储区分配。关于全局对象,是在main()函数执行前就分配好了的。其实,在main()函数中的显示代码执行之前,会调用一个由编译器生成的_main()函数,而_main()函数会进行所有全局对象的的构造及初始化工作。而在main()函数结束之前,会调用由编译器生成的exit函数,来释放所有的全局对象。比如下面的代码:

    void main(void)

    {

     … …// 显式代码

    }

      实际上,被转化成这样:

    void main(void)

    {

     _main(); //隐式代码,由编译器产生,用以构造所有全局对象

     … … // 显式代码

     … …

     exit() ; // 隐式代码,由编译器产生,用以释放所有全局对象

    }

      所以,知道了这个之后,便可以由此引出一些技巧,如,假设我们要在main()函数执行之前做某些准备工作,那么我们可以将这些准备工作写到一个自定义的全局对象的构造函数中,这样,在main()函数的显式代码执行之前,这个全局对象的构造函数会被调用,执行预期的动作,这样就达到了我们的目的。 刚才讲的是静态存储区中的全局对象,那么,局部静态对象了?局部静态对象通常也是在函数中定义的,就像栈对象一样,只不过,其前面多了个static关键字。局部静态对象的生命期是从其所在函数第一次被调用,更确切地说,是当第一次执行到该静态对象的声明代码时,产生该静态局部对象,直到整个程序结束时,才销毁该对象。

      还有一种静态对象,那就是它作为class的静态成员。考虑这种情况时,就牵涉了一些较复杂的问题。

      第一个问题是class的静态成员对象的生命期,class的静态成员对象随着第一个class object的产生而产生,在整个程序结束时消亡。也就是有这样的情况存在,在程序中我们定义了一个class,该类中有一个静态对象作为成员,但是在程序执行过程中,如果我们没有创建任何一个该class object,那么也就不会产生该class所包含的那个静态对象。还有,如果创建了多个class object,那么所有这些object都共享那个静态对象成员。

      第二个问题是,当出现下列情况时:

     class Base

    {

     public:

      static Type s_object ;

    }

    class Derived1 : public Base / / 公共继承

    {

     … …// other data

    }

    class Derived2 : public Base / / 公共继承

    {

     … …// other data

    }

    Base example ;

    Derivde1 example1 ;

    Derivde2 example2 ;

    example.s_object = …… ;

    example1.s_object = …… ;

    example2.s_object = …… ; 

      请注意上面标为黑体的三条语句,它们所访问的s_object是同一个对象吗?答案是肯定的,它们的确是指向同一个对象,这听起来不像是真的,是吗?但这是事实,你可以自己写段简单的代码验证一下。我要做的是来解释为什么会这样? 我们知道,当一个类比如Derived1,从另一个类比如Base继承时,那么,可以看作一个Derived1对象中含有一个Base型的对象,这就是一个subobject。一个Derived1对象的大致内存布局如下:

      

      让我们想想,当我们将一个Derived1型的对象传给一个接受非引用Base型参数的函数时会发生切割,那么是怎么切割的呢?相信现在你已经知道了,那就是仅仅取出了Derived1型的对象中的subobject,而忽略了所有Derived1自定义的其它数据成员,然后将这个subobject传递给函数(实际上,函数中使用的是这个subobject的拷贝)。

      所有继承Base类的派生类的对象都含有一个Base型的subobject(这是能用Base型指针指向一个Derived1对象的关键所在,自然也是多态的关键了),而所有的subobject和所有Base型的对象都共用同一个s_object对象,自然,从Base类派生的整个继承体系中的类的实例都会共用同一个s_object对象了。

    展开全文
  • 在静态方法中如何注入静态对象

    千次阅读 2019-09-18 16:45:32
    静态方法中需要使用spring注入的对象,但是在运行使用过程中,此对象则是为null,所以会导致空指针异常 正常写的代码(咋一看是没啥毛病吧): @Autowired private static RedisTemplate<String, Object>...

    1.问题:

    在静态方法中需要使用spring注入的对象,但是在运行使用过程中,此对象则是为null,所以会导致空指针异常

    正常写的代码(咋一看是没啥毛病吧):

    @Autowired
    private static RedisTemplate<String, Object> redisTemplate;
    
    public static long getExpire(String key) {
    	return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    但是,此时的redisTemplate对象为null(这就尴尬了,对象咋没了,肯定是没注入进来,那是什么原因呢?)

    嗯,那是因为静态方法是属于类的,而普通方法则属于对象,spring注入只在容器中实例化变量的,并且静态是优先于对象存在的,所以直接在静态方法中调用注入的静态变量其实是null的。(那么问题来了,该如何解决呢?请看下面)

    2.解决方法:

    a.用@Autowired注解加载构造函数上

    我们知道@Autowired 注释,可以对类成员变量、方法及构造函数进行标注,完成自动装配的工作,此种方式就是在构造函数上使用@Autowired。

    代码如下:

    private static RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    public RedisUtils(RedisTemplate<String, Object> redisTemplate) {
    	RedisUtils.redisTemplate = redisTemplate;
    }
    
    public static long getExpire(String key) {
    	return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    此时redisTemplate对象是存在值的

     

    b.使用@PostContruct注解,来给所需要的静态对象赋值

    @PostConstruct是Java EE 5引入来影响Servlet生命周期的注解,被用来修饰非静态的void()方法,

    @PostConstruct在构造函数之后执行,init()方法之前执行。

    代码如下:

    @Autowired
    RedisTemplate<String, Object> redisTemplate;
    
    private static RedisUtils redisUtils;
    
    @PostConstruct
    public void init(){
    	redisUtils = this;
    	redisUtils.redisTemplate = this.redisTemplate;
    }
    
    public static boolean set(String key, Object value) {
    	try {
    		redisUtils.redisTemplate.opsForValue().set(key, value);
    		return true;
    	} catch (Exception e) {
    		e.printStackTrace();
    		return false;
    	}
    }

    而此时静态方法中则使用redisUtils.redisTemplate去调用对应的方法

     

     

    参考博客:https://blog.51cto.com/zhengjiang/2141118

    展开全文
  • spring项目注入静态对象

    千次阅读 2019-03-13 14:33:54
    项目中有的时候需要在封装的静态方法中注入对象进行业务处理。 例如: @Autowired private static RedisTemplate&amp;amp;lt;String,String&amp;amp;gt; redisTemplatePoxy; 如果是上面的方式进行注入,项目...
  • Unity 3D 静态对象

    千次阅读 2019-10-28 14:50:32
    静态对象是Unity提供的一个属性,它可以附加在游戏对象或者Prefab上。 它的原理是限制物体在运行中不能发生位移变化,预先生成一些辅助的数据,从而达成一种用内存换时间的优化方式。 静态元素的种类很多,选择...
  • C++的static关键字 static关键字可以用于修改局部变量,...同时,C++也支持静态对象。 C++的静态对象(static object) 当使用static关键字声明一个对象时,此对象就变成了静态对象。见下面两个表达式。 Test t
  • Spring 工作加载时初始化静态对象

    万次阅读 2018-10-08 16:31:47
    创建一个系统配置对象,而配置内容一般为静态变量,spring 实现静态变量在系统启动初始化的时候,初始化静态变量。 第一步 :声明该配置对象为bean ,这样spring工程启动时...第二步:创建静态对象 public class S...
  • 1. 对于全局对象,程序一开始,其...3. 对于静态(static)对象,当对象诞生时其构造函数被执行;当程序将结束时其析构函数才被执行,但比全局对象的析构函数早一步执行。 4. 对于以new方式产生出来的局部对象
  • Qt之Q_GLOBAL_STATIC创建全局静态对象

    千次阅读 2018-05-23 08:08:42
    所谓的全局静态对象,大多是在单例类中所见,之前写过一篇文章介绍如何实现一个单例类,在这里,这是最常见的方式来进行创建,需要自定义 static 类对象, 并进行手动初始化。而今天要说的是更简单的方式来实现,Qt ...
  • 主要原因在于:Spring的依赖注入实际上是使用Object.Set()进行注入的,Spring是基于对象层面的依赖注入,而静态属性/静态变量实际上是属于类的。 @PostConstruct和@PreDestroy @PostConstruct 为Jav...
  • 在C/C++中使用static关键字来定义或声明静态对象,主要有以下的应用场景: (1)static修饰局部对象,使其成为静态局部对象 将一个函数中定义的变量声明为static对象,那么在函数被多次调用的过程中,静态局部对象会...
  • C++ 构造,析构顺序(静态对象)

    千次阅读 2015-03-22 11:34:40
    C++ 构造,析构顺序(静态对象)
  • 静态对象是否调用构造函数?

    千次阅读 2015-05-31 20:26:58
    同时,静态成员变量也可以通过类名直接访问,比如下面的程序没有通过任何类对象访问,只是通过类访问a。 int main() { // static member 'a' is accessed without any object of B A a = B::getA(); return ...
  • c++ 静态对象 操作(static)

    万次阅读 2012-07-19 15:43:00
    静态对象是一种从构造开始到程序结束都存在的一种对象.它是独立于栈与堆的。 静态存储 变量定义在函数外或是用static关键字修饰的变量存放在静态存储区.放在静态存储区的数据在整个程序运行其间持续有效。   ...
  • Unity3D - 关于Static静态对象

    万次阅读 2015-08-03 11:16:49
    例如,渲染可以通过组合几个静态对象到一个单一的,大的对象被称为一个批处理。 一个游戏对象检查员在最右一个静态的复选框和菜单,这是用来在统一中,物体不会移动各种不同系统的通知。对象可以被标记为静态的...
  • 1.在栈上的静态对象会进入析构函数。 void func() { static classA a; } 2.在堆上的静态对象不会进入析构函数。 void func() { static classA* pA = new classA; }
  • 一、C#静态和实例概念 静态概念:公共的、全局的、不属于个别实例的定义。 实例概念:new 出来的具体单个对象。随着作用域定义,使用,销毁(多数实例,通过垃圾回收机制自动销毁)。 静态 实例 关键字...
  • 动态库之全局对象、静态对象

    千次阅读 2012-03-30 20:41:55
    我们都知道,全局对象是相对局部对象、静态对象而言的,具体的定义如下: 局部对象就是只在局部使用比如在函数里,复合语句里,出了局部环境就不存在了。  静态对象分为静态全局对象和静态局部对象:静态局部对象...
  • 多久不用C++ ,好多東西都模糊了,最近跟人討論全局和靜態... 全局与静态对象析构的顺序class A destructor delete a; class B destructor 局部变量 class D destructor // 局部静态变量 class C destructor // 全局
  • 全局对象的构造函数将在main函数之前运行。析构在main函数之后运行。 函数内部的static对象的构造函数将在第一...若包含静态局部对象的函数未被调用,则也不进行析构。 可以通过atexit函数指定当离开main或者调用exit
  • 静态对象作为参数创建一个非静态的对象,当参数对象改变时,非静态的对象会发生改变么?
  • (3)在调用实例成员时,需要使用对象名(实例).实例中的成员。 (4)在调用静态成员的时候,需要使用类名.静态成员的名字。 class Person { // 在别的文件调用此方法时: // Person m = new Person; // m.M...
  • 2.静态对象(包括局部静态对象和全局静态对象)的析构函数在程序从main中退出,或者是标准的C库函数exit被调用时才调用。多数情况下main函数的结尾也是调用exit来结束程序的,这就意味着在析构函数内部使用exit函数...
  • c++ 非静态成员引用必须与特定对象相对

    万次阅读 多人点赞 2019-08-07 14:39:51
    小白我在使用C++类成员时,遇到错误显示:非静态成员引用必须与特定对象相对 代码片段为: struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {...
  • 静态方法随着类的加载而加载,存在方法区中,而非静态方法随着对象的创建而存在,存在对象存放的堆内存中, 因此,当类加载之后没有创建对象之前,静态方法已经加载,可以通过类名.静态方法名使用,但是此时非静态...
  • 对象和类——类的静态成员

    千次阅读 2018-05-29 10:07:53
    这是因为静态类成员是单独存储的,而不是对象的组成部分,所以不是在创建类对象时被定义的,因此不能在类中进行初始化,否则每创建一个对象都会初始化静态成员了。 cout ; //Error 刚才我们不是说可以使用类名...
  • C++实现只能动态或者静态创建对象

    万次阅读 2017-09-02 22:36:18
    C++如何实现类对象只能动态分配或只能静态分配C++中建立类的对象有两种方式: (1)静态建立,例如 A a; 静态建立一个类对象,就是由编译器为对象在栈空间中分配内存。使用这种方法,是直接调用类的构造函数。 ...
  • 1.静态资源的回收: 1.1.类被jvm加载时会为静态资源分配内存。当一个线程启动,类被加载时,静态资源会被分配内存 1.2.静态资源在类被卸载时被回收。类在ClassLoader存在的情况下不会被卸载,...2.对象的回收 当一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,590,258
精华内容 636,103
关键字:

静态对象