C++笔记 | 类数据成员 const static

最新推荐文章于 2024-11-06 23:10:00 发布
最新推荐文章于 2024-11-06 23:10:00 发布
阅读量139 收藏
点赞数
分类专栏： C++ 文章标签： c++ 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45379253/article/details/105983991
版权

类：成员，常成员，静态成员，常静态成员搞不懂；举了个例子终于搞清楚了
踩了不少坑

代码

#include <stdio.h>
#include <stdlib.h>

#include <iostream>
using namespace std;

class Student {
 public:
  /* 每个对象都会有一个的数据成员 */
  int age_;
  const int kGender;  // const确保一经赋值不会被修改
                      // true 男 false 女

  /* static 所有类对象共用一个常量数据成员 */
  static int kCount;  // 所有类对象共用的一个数据, 若不在类外赋值则无法使用
                      // 有const就无法修改
  const static int kSchool;  // #1
  // 假如说学生都是一个学校的,学校代码是123,学生不转学
  // const static int kSchool = 123;  // 等同于 #1+#2
  // 一个变量只有拥有类外定义的情况下，才能被获得地址。下面kPi同
  // 因此这种写法不会被允许在后面被打印出地址
  // 真的不会, 将(int*)变为(int* const)都不会
  const static double kPi;  // #3
  // constexpr static double kPi = 3.14159; // 等同于 #3+#4

 public:
  Student(int age = 18, const bool gender = true) : age_(age), kGender(gender) {
    kCount++;
  }
};

int Student::kCount = 0;  // 若不在类外赋值则无法使用
                          //而且必须这么做, 不像常量int类还可以放在类内赋值
const int Student::kSchool = 123;     // #2
const double Student::kPi = 3.14159;  // #4

int main() {
  // cout << Student.age_ << endl;     //不允许使用类名调用数据
  // cout << Student.kGender << endl;  //不允许使用类名调用数据
  // cout << Student.kCount << endl;   //不允许使用类名调用数据
  // cout << Student.kSchool << endl;  //不允许使用类名调用数据
  // cout << Student.kPi << endl;      //不允许使用类名调用数据
  // 同样不可以使用类名调用函数

  // cout << Student::age_ << endl;     //只有对象才有非静态成员
  // cout << Student::kGender << endl;  //只有对象才有非静态成员
  cout << "Student::kCount\t" << Student::kCount << endl;
  cout << "Student::kPi\t" << Student::kPi << endl;
  cout << "Student::kSchool\t" << Student::kSchool << endl;
  cout << endl << endl;

  Student s1(19, true);
  cout << "s1.age_\t" << s1.age_ << endl;
  cout << "s1.kGender\t" << s1.kGender << endl;
  cout << "s1.kCount\t" << s1.kCount << endl;
  cout << "s1.kSchool\t" << s1.kSchool << endl;
  cout << "s1.kPi\t" << s1.kPi << endl;
  cout << endl;

  Student s2(17, false);
  cout << "s2.age_\t" << s2.age_ << endl;
  cout << "s2.kGender\t" << s2.kGender << endl;
  cout << "s2.kCount\t" << s2.kCount << endl;
  cout << "s2.kSchool\t" << s2.kSchool << endl;
  cout << "s2.kPi\t" << s2.kPi << endl;
  cout << endl << endl;

  printf("&s1.age_\t%p\n", &s1.age_);
  printf("&s2.age_\t%p\n", &s2.age_);
  cout << endl;

  printf("&s1.kGender\t%p\n", &s1.kGender);
  printf("&s2.kGender\t%p\n", &s2.kGender);
  cout << endl;

  printf("&s1.kCount\t%p\n", &s1.kCount);
  printf("&s2.kCount\t%p\n", &s2.kCount);
  printf("&Student::kCount\t%p\n", &Student::kCount);
  cout << endl;

  printf("&s1.kSchool\t%p\n", &s1.kSchool);
  printf("&s2.kSchool\t%p\n", &s2.kSchool);
  printf("&Student::kSchool\t%p\n", &Student::kSchool);
  cout << endl;

  printf("&s1.kPi\t%p\n", &s1.kPi);
  printf("&s2.kPi\t%p\n", &s2.kPi);
  printf("&Student::kPi\t%p\n", &Student::kPi);
  cout << endl << endl;

  cout << "&s1.age_\t" << (int*)&s1.age_ << endl;
  cout << "&s2.age_\t" << (int*)&s2.age_ << endl;
  cout << endl;
  cout << "&s1.kGender\t" << (int*)&s1.kGender << endl;
  cout << "&s2.kGender\t" << (int*)&s2.kGender << endl;
  cout << endl;

  cout << "&s1.kCount\t" << (int*)&s1.kCount << endl;
  cout << "&s2.kCount\t" << (int*)&s2.kCount << endl;
  cout << "&Student::kCount\t" << (int*)&Student::kCount << endl;
  cout << endl;

  cout << "&s1.kSchool\t" << (int*)&s1.kSchool << endl;
  cout << "&s2.kSchool\t" << (int*)&s2.kSchool << endl;
  cout << "&Student::kSchool\t" << (int*)&Student::kSchool << endl;
  cout << endl;

  cout << "&s1.kPi\t" << (int*)&s1.kPi << endl;
  cout << "&s2.kPi\t" << (int*)&s2.kPi << endl;
  cout << "&Student::kPi\t" << (int*)&Student::kPi << endl;
  cout << endl;

  system("pause");
}
/*
  const static 和 static const一样，
  都不能在类内直接初始化非整形常量，
  可以修饰int，bool，char，
  但不能修饰其他类型（如double，float）
  在c++11中，可以使用 constexpr static 或者 static constexpr
  来修饰非整形静态成员常量
  ----
  为什么标准不允许这一行为？
  Bjarne这样解释：
  一个类会被特别定义在一个头文件中，并且头文件会被包含在许多转换单元里。
  但是，为了防止链接规则过于复杂，C++需要每一个对象有特定的定义。
  如果C++允许存储在内存中的对象进行类内定义，那么这一规则将会被打破。
  ----
  为什么只有static const integral类型以及enums被允许类内初始化呢？
  这个答案就在Bjarne的那段话中。“C++需要每一个对象有特定的定义。
  如果C++允许存储在内存中的对象进行类内定义，那么这一规则将会被打破。”

  注意只有static const integers 会被看作编译时的常量。
  编译器了解这样的integer在任何情况下都不会改变，
  因此编译器才可以对其做出特有的优化与改进，编译器会简单的将其内联化这样的变量，
  因而不再使其保存在内存中。因为保存在内存中的需求被移除了，使得他们成了Bjane所说规则的例外。

  值得注意的是，即使static const
  integral这样的变量被允许使用类内初始化，但是获取这样的变量的地址是不被允许的。
  一个变量只有拥有类外定义的情况下，才能被获得地址。
*/

结果

Student::kCount 0
Student::kPi    3.14159
Student::kSchool        123


s1.age_ 19
s1.kGender      1
s1.kCount       1
s1.kSchool      123
s1.kPi  3.14159

s2.age_ 17
s2.kGender      0
s2.kCount       2
s2.kSchool      123
s2.kPi  3.14159


&s1.age_        000000000061FE18
&s2.age_        000000000061FE10

&s1.kGender     000000000061FE1C
&s2.kGender     000000000061FE14

&s1.kCount      0000000000408030
&s2.kCount      0000000000408030
&Student::kCount        0000000000408030

&s1.kSchool     0000000000405004
&s2.kSchool     0000000000405004
&Student::kSchool       0000000000405004

&s1.kPi 0000000000405008
&s2.kPi 0000000000405008
&Student::kPi   0000000000405008


&s1.age_        0x61fe18
&s2.age_        0x61fe10

&s1.kGender     0x61fe1c
&s2.kGender     0x61fe14

&s1.kCount      0x408030
&s2.kCount      0x408030
&Student::kCount        0x408030

&s1.kSchool     0x405004
&s2.kSchool     0x405004
&Student::kSchool       0x405004

&s1.kPi 0x405008
&s2.kPi 0x405008
&Student::kPi   0x405008

请按任意键继续. . .

参考

CSDN | 不能在类内初始化非const static成员
CSDN | error: ‘constexpr’ needed for in-class initialization of static data member

「已注销」
关注
专栏目录
C语言——指针（1.2.指针变量的定义和初始化）
一个努力的程序猿
10-27 2745
上一小节，我们了解到了关于变量的储存地址，并且了解到了变量名，变量的值，变量的地址之间的关系。简单回顾一下就是，需要存储的值存储在变量里面，通过访问变量的地址可以找到变量对应存储的值。 这一小结我们开始学习指针变量的定义和初始化： 指针的定义：存放变量的地址需要一种特殊类型的变量，而这种特殊的数据类型被称作指针。 指针变量：具有指针类型的变量，被成为指针变量，其定义形式如下： 类型关键字 *指针变量名 类型关键字代表指针变量要指向的变量的类型，即指针变量的类型（举个例子） int *pa; .
指针学习
qq_34128332的博客
07-24 240
基本知识 主要来源为C++ primer 第六版内容 关于两个问题： 1、数组的指针表示方法 int a[10]; int (*ps)[10] = &a; // int (*)[10] int* ps1 = a; // int * 如果将(*ps)[10] 改为(*ps)[20]，会导致错误: 不能将 “int ()[10]" 类型的值分配到 "int ()[20]” 类型的实体". 将ps1 = a 更改为ps1 = &a,同样会出错 int (*)
自学C语言日记-第三天
m0_61447412的博客
03-31 131
为了有效使用内存,就把内存划分为一个个小单元,每个内存单元的大小是.为了能够有效地访问到内存的每个单元,就给内存单元进行了编号,这些编号称为该内存单元的地址.内存的使用类似于现实生活中对于空间的使用.一个地址的例子a的地址:000000000061fe1cpa的值:6422044pa的地址000000000061fe10用来存放地址的变量叫做解引用操作符20请按任意键继续. . .
指针的简单使用
正义
06-26 225
昨天写队列Demo的运行的时候遇到了一个小问题，就是声明队列指针的时候，忘记给指针赋值。导致运行了好几次都没啥反应。下面是我的错误代码： #include "stdio.h" #include "CirQueue.c" int main(){ CirQueue *Q; InitQueue(Q); return 0; } 平常写的java，几天不用c，都忘记...
C 语言 —— 指针、函数、数组
柚咖小窝
09-23 345
在这一部分的学习中，我们主要是回顾一下之前学习的函数和数组的知识，并看一下它们和指针的联系。 1. 指针和函数 1.1. 分析地址传递 我们首先来看看指针和函数的联系。在讲函数参数传递机制的时候，我们提到了地址传递，当时用到的程序是交换函数的两个参数的值，代码如下： #include<stdio.h> int swap(int *a, int *b); int main() { int a = 30, b = 24; printf("main 交换前：a=%d, b=%d\n",
C++笔记之类的静态成员(static)、友元(friend)和常对象(const)
小笨聪
04-10 1102
一、类的静态成员 1.目的 静态成员（关键字：static）是解决同一个类的不同对象之间数据和函数共享问题。区分全局变量，全局变量也能实现数据共享，但安全性和封装性被破坏了。 2.静态数据成员 (1)使用关键字static在类内声明，类外定义和初始化，用::指明所属的类。 (2)静态数据成员属于整个类，每个对象均可引用。静态数据成员的值对所有对象来说都是一样的。如果改变它的值，则各个对象中这个数据...
C++ 笔记6 | 静态成员 成员指针
jackJruit的博客
04-10 922
十八 静态成员(static) 1 静态成员变量 1）语法 class 类名{ static 数据类型 变量名;//声明 }; 数据类型 类名::变量名 = 初值;//定义和初始化 2）普通成员变量属于对象，而静态成员变量不属于对象，静态变量内存在全局区，可以把静态变量理解为被限制在类中使用的全局变量. 3）普通成员变量在对象构造时定义和初始化，而静态成员变量在类的外部单独定义和初始化。 4）使用方法 类名::静态成员变量;//推荐 对象.静态成员变量;//和上面等价 2 静态成员函数 1）语法 class
C++笔记 | 第3课 类
yxj的博客
03-14 321
C++笔记 第3课 类 ##类(class)的定义 类是将数据和相应对这些数据的操作函数进行封装，并设置访问权限。class不同于struct、union，struct、union是纯数据类型，但不包括函数(操作) 类是对象的抽象，而对象是类的实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板 (模子)。 ...
C++中静态成员函数与静态成员变量（static ）
01-20
C++中静态成员函数与静态成员变量（static ） 这篇介绍了静态成员函数与静态成员变量，是我的读书笔记，我希望它够简短但又比较全面，起到复习的作用。如果有一些C++知识记不清楚了，它可以帮你很快回忆起来。 复习...
C++考研笔记：const关键字与static特性详解
4. **成员函数修饰**：`const` 可用于区分普通成员函数和常成员函数，后者在执行过程中不会修改类中的任何数据成员。这对于保证数据封装和对象状态的完整性至关重要。 接下来，我们关注static关键字在C++中的四个...
c语言内存操作
lingmessy的博客
12-20 494
c语言内存操作 基本概念 内存 malloc()原理 操作及注意事项 具体函数 void *malloc(size_t size) 申请一个所需大小的内存空间 void *calloc(size_t nitems, size_t size) 申请一个所需大小的内存空间，并设置内容为零 void *realloc(void *ptr, size_t size) 尝试重新分配之前申请的内存空间大小 void free(void *ptr) 释放分配的内存空间 实例： char *str = (char *)ma
C语言指针加一的解释
你访问的页面不存在
06-09 2911
（最近读Cprimerplus，做一些笔记） 直接看代码： short a[4]; double b[4]; short * p1 = a; double * p2 = b; printf("%p %p\n", p1, p1+1); printf("%p %p\n", p2, p2+1); 输出是： 000000000061FE08 000000000061FE0A 0000000...
C语言形参传递
qq_42951723的博客
03-27 1106
C语言中的形参传递 值传递 #include <stdlib.h> #include <stdio.h> void Exchg1(int x, int y) /* 定义中的x,y变量被称为Exchg1函数的形式参数 */ { printf("x地址 = %p, y地址 = %p.\n", &x, &y); int tmp; tmp = x; x = y; y = tmp; printf("x = %d, y = %d.
C语言——指针（1.1.变量的内存地址)
一个努力的程序猿
10-26 1113
在以往的学习中，我们了解到，c语言中变量都是存储在计算机中特定的内存单元中，而内存中的每个单元都对应了唯一的地址，而如果我们要去获取这个地址则我们需要用到一个符号： &——取址运算符 %p——地址类型 例1.1 #include <stdio.h>int main(void) { int a=0,b=1; char c='A'; printf("a is %d,&a is %p\n",a,&a); printf("b is %d,&...
＜数据结构与算法＞-Python列表-栈-队列
kobe_okok的博客
08-25 140
文章目录1 列表2 栈3 队列 1 列表 Python中的列表与C中的数组有哪些不同？ 首先想一下C中数组获取数据的时间复杂度。 #include <stdio.h> #include <stdlib.h> int main(void) { int arr[3] = {1,2,3}; printf("a[2]=%d\n",arr[2]); printf("a的地址是=%p\n",arr); printf("a[0]的地址是=%p\t a[0]存
C语言指针一（地址法理解）
myaijarvis notebook
03-29 440
文章地址：https://www.myaijarvis.com/archives/299/ 直接按例子来理解 #include <iostream> using namespace std; int main() { int a=0; int *p; cout<<"*p:"<<*p<<" &p:"<<&a...
C/C++的指针实现原理
Desire_Pyramid的博客
04-03 695
#include <stdio.h> int main(void){ /** *1、以下是通过阅读指针的VB实现代码，自己总结了指针的本质到底是什么，仅供参考，欢迎留言指正 *2、关于指针结合具体数据结构的实现，还在学习当中，我会继续完善 */ int i = 1024;//分配一块内存空间 printf("i的值（十进制表示）...
C++——C++11新语法（中）
最新发布
Wangx_wang的博客
11-06 1027
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
C 学习（4）
search7的博客
11-05 839
C语言学习，每个模块来自工作中的？？？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值