静态成员

C++学习笔记之静态成员

别来无恙 提交于 2020-03-09 07:01:44
# include <iostream> using namespace std ; /* 静态成员 1)静态成员数据: ①为多个对象共享 ②不是对象成员 ③类内声明,类外定义和初始化 2)静态成员函数: ①提供不依赖于类的共同操作,没有this指针 ②只能访问静态成员变量 ③调用方式:类名::函数 或 对象.函数(成员数据也是如此) */ class Book { private : string m_name ; public : static int count ; Book ( string name ) : m_name ( name ) { } ~ Book ( ) { } int get_add_count ( ) { ++ count ; return count ; } static void set_count ( ) { cout << "count is increasing!" << endl ; count + = 66 ; } } ; int Book :: count = 0 ; int main ( ) { Book b1 ( "math" ) ; Book b2 ( "chinese" ) ; cout << b1 . get_add_count ( ) << endl ; cout << b2 . get_add_count ( ) <<

[YTU]_2641 9 填空题:静态成员---计算学生个数)

断了今生、忘了曾经 提交于 2020-03-08 08:29:10
题目描述 学生类声明已经给出,在主程序中根据输入信息输出实际建立的学生对象个数,以及所有学生对象的成绩总和。 在下面的程序段基础上完成设计,只提交 begin 到 end 部分的代码 #include <iostream> #include <string> using namespace std; class student { private: stringname; // 学生姓名 intage; // 学生年龄 intscore; // 学生成绩 static intcount; // 记录学生对象个数 staticint sum; // 记录所有学生的总成绩 public: student(stringn,int a,int s); // 构造函数 staticint get_count(); // 静态成员函数,获取 count 的值 staticint get_sum(); // 静态成员函数,获取 sum 的值 }; // 将程序需要的成份写下来,只提交 begin 到 end 部分的代码 //******************** begin******************** int student::count=0; _____(1)_______; ________(2)___________ { name=n; age=a; score=s;

C++中静态数据成员,静态成员函数(static)

笑着哭i 提交于 2020-03-07 10:34:20
类中的静态成员 1. 在类中的静态数据,属于类共享,不属于对象独有 2. 即使没有定义对象,静态成员也是存在的 3. 静态数据成员在类中说明,在类外定义 并且会给他分配内存空间,并初始化( 一经定义则必须初始化) 4. 可以通过对象去访问静态成员,但是这里容易让人产生误解,以为他们是成员变量( 静态成员是被所有对象共享的 所以也可以去修改它) 我们一般通过 类名::静态成员 去访问它们 5. 他的生存周期一直存在于整个程序的生命周期 静态成员的定义 int Class : : a=10; 数据类型+类名+作用域符号+变量名=10; 静态成员函数 1. 静态成员函数属于一个类,而不属于类中的任何对象 2. 静态成员函数的说明和定义与静态数据成员一样,函数可以实现在类体内,也可以实现在类体外 3. 静态成员函数在实现中,可以直接使用静态成员,也可以通过对象来使用非静态成员!! 这里说明,静态成员函数不能是虚函数,不能直接访问非静态成员,因为他是类所有,而不是对象所有 虚函数和静态成员是对象创建的时候才会有的,这里静态成员函数不属于对象,那么也就不能定义为虚函数,更不能使用成员变量 C语言的static和C++static总结: static在C中的用法,对于C++来说是全盘接受的 两者的不同就在于C++中的类使用 C中的static变量其影响不在于作用域,在于其存储方式

类的静态成员变量

僤鯓⒐⒋嵵緔 提交于 2020-03-02 18:03:21
通过对象名能够访问public成员变量,每个对象的成员变量都是专属的,成员变量不能再对象之间共享,先来看一个例子: # include <stdio.h> class Test { private : int mCount ; public : Test ( ) : mCount ( 0 ) { mCount ++ ; } ~ Test ( ) { -- mCount ; } int getCount ( ) { return mCount ; } } ; Test gTest ; int main ( ) { Test t1 ; Test t2 ; printf ( "count = %d\n" , gTest . getCount ( ) ) ; printf ( "count = %d\n" , t1 . getCount ( ) ) ; printf ( "count = %d\n" , t2 . getCount ( ) ) ; return 0 ; } 结果: sice@sice:~$ g++ a.c sice@sice:~$ ./a.out count = 1 count = 1 count = 1 这是因为我们定义的mCount是一个成员变量,而成员变量是每个对象自己都有一套的,也就是说gTest,t1,t2分别拥有一个mCount

剖析含有静态成员变量类的内存分布

依然范特西╮ 提交于 2020-03-01 15:39:21
如题所诉,对于含有静态成员变量的类其内存分布应该怎样呢?首先,我们知道静态成员变量任何对象都可以访问,但是它只存在一份,被所以对象共享。但是不属于对象本身,它在对象外构造。举例如下: #include <iostream> using namespace std; class Point3d { public: virtual ~Point3d(){} void print() { printf("&Point3d::x = %p\n", &Point3d::x);//打印在类Point3d中成员x的偏移值。 printf("&Point3d::y = %p\n", &Point3d::y);//打印在类Point3d中成员x的偏移值。 printf("&Point3d::z = %p\n", &Point3d::z);//打印在类Point3d中成员x的偏移值。 } protected: static Point3d origin; float x, y, z; }; int main() { Point3d s; s.print(); cout << sizeof(s) << endl;//打印对象的大小。 return 0; } 大家分析一下就知道,结果是:&Point3d::x = 00000008 &Point3d::y = 0000000c &Point3d::z =

静态成员函数和静态成员变量

≡放荡痞女 提交于 2020-03-01 07:40:51
静态成员变量 作用:实现多个对象间数据共享。相当于不同对象间共享一个成员变量 例: 用_total 统计建立了多少个对象,每建立一个新的对象,total++,每个对象都可以访问total,且结果相同。 class A { 11 public : 12 static int _total ; 13 A ( ) { 14 _total ++ ; 15 } } ; 一个类可以有多个静态成员变量,所有对象共享 **static 成员变量和普通 static 变量一样,都在内存分区中的全局数据区分配内存,到程序结束时才释放。**所static成员变量不会随着对象的创建而分配内存,也不会随对象销毁而释放内存。 必须初始化 且在类外进行,可以不赋值默认为0 因为 全局数据区的变量都有默认的初始值 0,而动态数据区(堆区、栈区)变量的默认值是不确定的,一般认为是垃圾值。 对于静态成员变量不同 对象既可以通过对象名访问,也可以通过类名访问,访问的都是内存上的同一块空间(this指针也可以访问) 初始化 前面说过类只是一个模板,只有在建立对象后才能在内存放存放数据,在类中是不能对成员函数进行初始化的,因为没有地方存储。而静态成员变量是不依赖对象存在的,故其初始化在类外,没有初始化的静态成员变量是无效的。 (实际上是初始化在内存上开辟空间,才能存储数据) type 类名:: 成员变量名 = value

Dart类中static静态成员及访问

喜欢而已 提交于 2020-02-29 11:22:28
class Person { //用static关键字声明静态成员 static var name = "zz" ; //静态值 var age = 18 ; static void show ( ) { //静态方法可以访问静态成员,但是不可以访问非静态的成员 print ( name ) ; } void getInfo ( ) { //非静态成员可以访问静态成员以及非静态成员 print ( name ) ; //访问静态属性 print ( this . age ) ; //访问非静态属性 show ( ) ; //调用静态方法 } } void main ( ) { //静态成员无需实例即可进行访问 print ( Person . name ) ; Person . show ( ) ; } 来源: CSDN 作者: 任我行RQ 链接: https://blog.csdn.net/AK852369/article/details/104569983

千锋逆战班day20 常用类1

我与影子孤独终老i 提交于 2020-02-29 03:49:37
千锋逆战学习第20天 努力不一定成功,不努力一定失败 Day 20 3、静态内部类 不依赖外部类对象,可直接创建或通过类名访问,可声明静态成员 只能直接访问外部类的静态成员(实例成员需实例化外部类对象) Outer.Inner inner=new Outer.Inner(); Outer.Inner.show(); package com.qf.day20.t1.statics; public class TestAtaticInnerClass { public static void main(String[] args) { System.out.println(Outer.Inner.b); Outer.Inner in=new Outer.Inner(); in.m2(); } } class Outer{ private static int a=10; String s="hello"; //静态内部类 static class Inner{ static int b=20; public void m2(){ System.out.println(a); //System.out.println(Outer.s); //Error 静态不能直接访问非静态 System.out.println("Inner m2()"); } } } 4、局部内部类

java基础学习3---面向对象

妖精的绣舞 提交于 2020-02-27 10:59:35
1、面向对象 对象:用来描述客观事物的一个实体,由一组属性和方法构成。 面向对象: 人关注对象 人关注事物信息 类 确定对象将会拥有的属性和方法 类的特点: 类是对象的类型 具有相同属性和方法的一组对象的集合。 类和对象的关系 类是抽象的概念 对象是一个能看到的具体实体 类是对象的类型 对象是特定类型的数据 具体开发中,先定义类再实例化对象。 对象实例化 Cat cat = new Cat ( ) ; 实例化过程分两部分: 声明对象 Cat cat 实例化对象 new Cat() 注意: 1.每次new对象都会产生新的实例化对象。 2.多个对象可以指向同一块实例化空间。 3.对象必须被实例化之后才能使用。 4.对象间的引用,实际上传递的是堆内存的引用。 构造方法 1、构造方法与类同名,没有返回值。 2、只能在对象实例化的时候调用。 3、没有指定构造方法时,系统会自动添加无参的构造方法。 4、当指定构造方法时,无论是有参、无参的构造方法,都不会自动添加无参的构造方法。 5、一个类中可以有多个构造方法。 单一职责原则 单一职责原则(SRP:single responsibility principle),又称单一功能原则。 面向对象的五个基本原则之一(SOLID:SRP、OCP开放封闭原则、LSP里氏替换原则、DIP依赖倒置原则、ISP接口分离原则)。

C++笔记(3):一些C++的基础知识点

99封情书 提交于 2020-02-26 23:05:08
前言: 找工作需要,最近看了下一些C++的基本概念,为范磊的 《零起点学通C++》,以下是一些笔记。 内容:   delete p;只是删除指针p指向内存区,并不是删除指针p,所以p还是可以用的。删除空指针所指向内存是可以的。   堆中的变量和对象时匿名的,没有名称,只能通过指针来访问。   在堆中创建对象时,在分配内存的同时会调用类的构造函数,在删除堆中对象时,会调用类的析构函数。   为了避免内存泄露,在删除一个指针后应该将其其值赋为0。   常量指针是指针指向的内存区域地址不能改变,但是该内存地址里保存的值是可以改变的,比如int a; int * const p = &a;   指向常量的指针表示指针指向的对象是不能被修改的,但是该指针可以被修改,即该指针可以指向另一块目标内存地址。比如const int a = 0; const int *p = &a; 如果A是一个类,也可以为const A* p = new A;   而指向常量的常指针表示指针本身不能被修改,其指向的内存地址内容也不能被修改。比如const int a = 0; const int * const p = &a;   引用就是别名常量。   堆中的地址是用指针来操作的,用不到别名。   如果在main函数前面的其它函数的声明和定义是一起的,则表明这个函数是内联函数!因此当该函数较长时