const(每个对象中的常量), static const(类的编译时常量)

 1 #include <iostream>
 2 using namespace std;
 3
 4 class Values
 5 {
 6 private:
 7
 8     //类里的
 9     const int cSize; //常量成员的初始化,必须在构造函数中进行,每个对象都有,只是成员常量数据在初始化就不能改变
10
11
12     //禁止在类内对"非const的静态成员"进行初始化
13     //static int sFloat = 100; //Values.cpp:8:24: error: ISO C++ forbids in-class initialization of non-const static member ‘Values::sFloat’
14     static float sFloat; //类的静态成员,所以对象共享同一块内存单元
15     static int sInts[];
16
17
18
19     static const float scFloat; //类的静态常量成员在类中初始化
20     static const int scInts[];
21
22     int size;
23
24 public:
25     Values(const int cSize, int sz) : cSize(cSize), size(sz) {}
26
27     void print() const;
28
29     static void printStatic();
30 };
31
32
33 //类的普通private成员
34 //int Values::size = 100; //error C2350: ‘Values::size‘ is not a static member
35
36 //类的静态数据成员初始化
37 float Values::sFloat = 1.1;
38 int Values::sInts[] = {1, 2, 3};
39
40 //类静态常量数据成员初始化
41 const float Values::scFloat = 100.01;
42 const int Values::scInts[] = {11, 22, 33};
43
44 //定义一个全局变量size
45 int size = 7;
46
47   //成员函数中,可以访问到类的静态成员
48 void Values::print() const
49 {
50     cout<<"::size = "<<size<<endl;
51     cout<<"Values::cSize = "<<cSize<<endl;
52     cout<<"Values::size = "<<size<<endl;
53     cout<<"Values::sFloat = "<<sFloat<<endl;
54     cout<<"Values::scFloat = "<<scFloat<<endl;
55 }
56
57   //在静态成员函数中,只能访问到类的静态成员
58 void Values::printStatic()
59 {
60     cout<<"printStatic(), Values::scFloat = "<<scFloat<<endl;
61     cout<<"printStatic(), Values::scInts[] = {"<< scInts[0] <<", " <<scInts[1] << ", " << scInts[2] <<"}"<<endl;
62
63     cout<<"printStatic(), Values::sFloat = "<<sFloat<<endl;
64     cout<<"printStatic(), Values::sInts[] = {"<< sInts[0] <<", " <<sInts[1] << ", " << sInts[2] <<"}"<<endl;
65 }
66
67
68 int main()
69 {
70     Values v(1, 3);
71
72     v.print();
73
74     Values::printStatic();
75
76     return 0;
77 }

输出:

::size = 3
Values::cSize = 1
Values::size = 3
Values::sFloat = 1.1
Values::scFloat = 100.01

printStatic(), Values::scFloat = 100.01
printStatic(), Values::scInts[] = {11, 22, 33}
printStatic(), Values::sFloat = 1.1
printStatic(), Values::sInts[] = {1, 2, 3}

时间: 2024-11-09 06:05:58

const(每个对象中的常量), static const(类的编译时常量)的相关文章

java中的关键字static(静态变量)和final定义常量

1 package point; 2 3 class Point { 4 5 int x = 0; 6 int y = 0; 7 static int z = 100; // 定义静态变量z,类变量 8 static final double PI = 3.1415926;// final定义常量,它的值在运行时不能被改变 9 10 Point(int a, int b) { 11 //PI=3.1415926; 12 /* 13 * 当使用静态常量的时候,不能在构造函数中初始化, 因为静态时,

在JAVA中利用public static final的组合方式对常量进行标识

在JAVA中利用public static final的组合方式对常量进行标识(固定格式). 对于在构造方法中利用final进行赋值的时候,此时在构造之前系统设置的默认值相对于构造方法失效. 常量(这里的常量指的是实例常量:即成员变量)赋值: ①在初始化的时候通过显式声明赋值.Final int x=3: ②在构造的时候赋值. 局部变量可以随时赋值. 1 package TomText; 2 //利用if语句,判断某一年是否是闰年. 3 public class TomText_28 { 4 p

java中的编译时常量与运行时常量

常量是程序运行期间恒定不变的量,许多程序设计语言都有某种方式,向编译器告知一块数据是恒定不变的,例如C++中的const和Java中的final. 根据编译器的不同行为,常量又分为编译时常量和运行时常量,其实编译时常量肯定就是运行时常量,只是编译时常量在编译的时候就被执行计算,并带入到程序中一切可能用到它的计算式中. 以Java为例,static final int a = 1将是一个编译时常量,编译后的符号表中将找不到a,所有对a的引用都被替换成了1. 而static final int b

探讨:编译时常量和运行时常量

编译时常量和运行时常量 C#有2种不同的常量定义方式:编译时常量(compile-time)和运行时常量(runtime).他们的行为方式有很大的不同,如果选用了错误的一个,那么将让程序的性能和正确性产生商榷.当然,一个系统最好没有任何问题,但是如果一定会存在一个问题,那么一个稍慢的但强壮的系统比一个速度更快的但很脆弱的系统要好.基于以上理由,在二者选其一的时候,你最好选择运行时常量. 运行时常量以 readonly 关键字定义,编译时是常量以 const 关键字定义: public const

《C++程序设计POJ》《WEEK3 类和对象进阶》成员对象和封闭类/友元/this指针/常量成员函数

// 构造函数赋值 CTyre(int r, int w):radius(r), width(w) { } 初始化列表 #include<iostream> using namespace std; /*成员对象和封闭类 成员对象: 一个类的成员变量是另一个类的对象 包含 成员对象 的类叫 封闭类 (Enclosing) */ class CTyre { private: int radius; int width; public: CTyre(int r, int w) :radius(r)

mybatis高级(2)_数据库中的列和实体类不匹配时的两种解决方法_模糊查询_只能标签

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="cn.cnsdhzzl.dao.StudentDao&q

C++中类中常规变量、const、static、static const(const static)成员变量的声明和初始化

C++类有几种类型的数据成员:普通类型.常量(const).静态(static).静态常量(static const).这里分别探讨以下他们在C++11之前和之后的初始化方式. c++11之前版本的初始化 在C++11之前常规的数据成员变量只能在构造函数里和初始化列表里进行初始化.const类型的成员变量只能在初始化列表里并且必须在这里进行初始化.static类型只能在类外进行初始化.static const类型除了整型数可以在类内初始化,其他的只能在类外初始化.代码如下: class A {

C++中的static const

提出问题 以下代码,能编译链接通过吗? void f(const int &value) { } class Test { public: static const int a = 1; }; int main() { f(Test::a); return 0; } 我的第一感觉是:应该没问题,吧.在VS 2013 实验了下,顺利通过,一切正常.然而gcc下是报错的:Undefined reference to 'Test::a'这是为什么? 分析问题 写作本文时所用的环境是gcc 4.8.2

C#中的readonly跟const用法小结

总结一下常量和只读字段的区别: 由来: 笔者也是在看欧立奇版的<.Net 程序员面试宝典>的时候,才发现自己长久以来竟然在弄不清出两者的情况下,混用了这么长的时间.的确,const与readonly 很像,都是将变量声明为只读,且在变量初始化后就不可改写.那么,const与readonly 这两个修饰符到底区别在什么地方呢?其实,这个牵扯出C#语言中两种不同的常量类型:静态常量(compile-time constants)和动态常量(runtime constants).这两者具有不同的特性