Const
• declares a variable to have a constant value
const int x = 123;
x = 27; // illegal!
x++; // illegal!
int y = x; // Ok, copy const to non-const
y = x; // Ok, same thing
const int z = y; // ok, const is safer
变量variable
常量 constant ，值不会发生变化的变量，如被const修饰的x
字面量 literal ，如整数123
Constants
• Constants are variables
– Observe scoping rules
– Declared with “const” type modifier
• A const in C++ defaults to internal linkage
– the compiler tries to avoid creating storage for a const -- holds the value in its symbol table.
– extern forces storage to be allocated
Compile time constants
const int bufsize = 1024;
• value must be initialized
• unless you make an explicit extern declaration:
extern const int bufsize;
• Compiler won't let you change it
• Compile time constants are entries in compiler symbol table, not really variables.
Run-time constants
• const value can be exploited
const int class_size = 12; 编译时常量
int finalGrade[class_size]; // ok
int x;
cin >> x;
const int size = x;
double classAverage[size]; // error! c++98是错的，不能用变量作为数组大小，c++11才对
Aggregates
• It’s possible to use const for aggregates, but storage will be allocated. In these situations, const means “a piece of storage that cannot be changed.
• However, the value cannot be used at compile time because the compiler is not required to know the contents of the storage at compile time.
const int i[] = { 1, 2, 3, 4 }; 数组元素不能修改
float f[i[3]]; // Illegal c++98标准，const变量不能做其他数组大小
struct S { int i, j; };
const S s[] = { { 1, 2 }, { 3, 4 } };
double d[s[1].j]; // Illegal
Pointers and const
• char * const q = "abc"; // q is const
*q = 'c'; // OK
q++; // ERROR
• const char *p = "ABCD"; // (*p) is a const char
*p = 'b'; // ERROR! (*p) is the const
Quiz: What do these mean?
string p1( “Fred" );
const string* p = &p1; //对象不能改
string const* p = &p1; //对象不能改
string *const p = &p1; //指针不能改
const在*之前说明对象不能不能改，在*后面表示指针不能改
Pointers and constants
Remember:
*ip = 54; // always legal since ip points to int
*cip = 54; // never legal since cip points to const int
ip = &ci错误，因为ci可能被*ip修改
cip = &ci正确，是因为cip指针不能修改对象，所以ci不会被修改，安全
String Literals
char* s = "Hello, world!";
• s is a pointer initialized to point to a string constant
• This is actually a const char* s but compiler accepts it without the const
• Don't try and change the character values (it is undefined behavior)
• If you want to change the string, put it in an array:
char s[] = "Hello, world!";
int main(){
char* s = "abc";
char a[] = "abc";
printf("s=%p\n", s);
printf("a=%p\n", a);
}
/*
输出：
s=0x103f41f9e 地址比a小
a=0x7ff7bbfc1334
a在栈内，s指向的内存在很小的地方
*/int main(){
char* s = "abc";
char a[] = "abc";
printf("s=%p\n", s);
printf("a=%p\n", a);
s[0] = 'c';
pringf("1\n");
a[0] = 'c';
printf("2\n");
}
/*
s[0] = 'c'报错
*/Conversions
• Can always treat a non-const value as const
void f(const int* x);
int a = 15;
f(&a); // ok
const int b = a;
f(&b); // ok
b = a + 1; // Error!
You cannot treat a constant object as non-constant without an explicit cast
(const_cast)
Passing by const value?
void f1(const int i) {
i++; // Illegal -- compile-time error
}
Returning by const value?
int f3() { return 1; }
const int f4() { return 1; }
int main() {
const int j = f3(); // Works fine
int k = f4(); // But this works fine too!
}
Passing and returning addresses
• Passing a whole object may cost you a lot. It is better to pass by a pointer. But it’s possible for the
programmer to take it and modify the original value.
• In fact, whenever you’re passing an address into a function, you should make it a const if at all possible.
• Example: ConstPointer.cpp, ConstReturning.cpp
const object
Constant objects
• What if an object is const?
const Currency the_raise(42, 38);对象里的任何一个成员变量都不能被修改
• What members can access the internals?
• How can the object be protected from change?
• Solution: declare member functions const
– Programmer declares member functions to be safe
Const member functions
• Cannot modify their objects
//不保证不修改，不是保证修改
int Date::set_day(int d){
//...error check d here...
day = d; // ok, non-const so can modify
}
//保证不修改成员变量，不会调用非const的成员函数
//因为调用了非const成员函数可能会修改成员变量
int Date::get_day() const {
day++; //ERROR modifies data member
set_day(12); // ERROR calls non-const member
return day; // ok
}Const member function
• Repeat the const keyword in the definition as well as
the declaration 声明和定义都要标注const
int get_day () const;
int get_day() const { return day };
• Function members that do not modify data should be
declared const
• const member functions are safe for const objects
Const objects
• Const and non-const objects
// non-const object
Date when(1,1,2001); // not a const
int day = when.get_day(); // OK
when.set_day(13); // OK
// const object
const Date birthday(12,25,1994); // const
int day = birthday.get_day(); // OK
birthday.set_day(14); // ERRORclass A{
int i = 0;
public:
A(int li):i(li){}
int getV() const{return i;}
void setV(int v){i = v;}
};
int main(){
A a(10);
const A aa(11);
a.setV(12);
cout << aa.getV() << endl;
aa.setV(13);//报错，不能修改成员变量
}class A{
int i = 0;
public:
A(int li):i(li){}
int f() const{
cout << "f() const" << endl;
reutrn i;
}
int f() const{
cout << "f()" << endl;
return i;
}
void setV(int v){i = v;}
};
int main(){
A a(10);
const A aa(11);
a.setV(12);
a.f();//调用无const的f()
aa.f();//调用有const的f()
}
//两个函数构成重载
//int f() const相当于int f(const A* this) const
//int f() 相当于int f(A* this)
//const函数指的是this是constConstant in class
class A {
const int i;
};• has to be initialized in initializer list of the constructor
//当i是const时
//不能用构造函数赋值
A(int x){
i = x;
}
//可以用初始化列表的方式给i设置初始化值
A(int x): i(x){}Compile-time constants in classes
class HasArray {
const int size;
int array[size]; // ERROR!
};
//• use "anonymous enum" hack 匿名枚举基础
class HasArray {
enum { size = 100 };
int array[size]; // OK!
};
//• Make the const value static:
class HasArray{
static const int size = 100;//static指所有对象使用同一个变量
int array[size];
}
//·static indicates only one per class(not one per obeject)Static
Static in C++
Two basic meanings
• Static storage
–allocated once at a fixed address
• Visibility of a name
• internal linkage
-
Don't use static except inside functions and
classes.
-
静态本地变量实际上是特殊的全局变量
-
它们位于相同的内存区域
-
静态本地变量具有全局的生存期，函数内的局部作用域
Uses of “static” in C++
Global static hidden in file
C语言规则，File 2编译通过，但链接时extern int s_local报错，因为在File1中属于static，只能在当前文件使用
Static inside functions
• Value is remembered for entire program
• Initialization occurs only once
• Example:
–count the number of times the function has been called
void f() {
static int num_calls = 0;
...
num_calls++;
}Static applied to objects
• Suppose you have a class
class X {
X(int, int);
~X();
...
};• And a function with a static X object
void f() {
static X my_X(10, 20);
...
}class A{
private:
int i;
public:
A(int li):i(li){
cout << "A()" << i << endl;
}
~A(){
cout << "~A()" << i << endl;
}
};
A a(10);
int main(){
cout << "main()" << endl;
cout << "end of main()" << endl;
}
/*
输出：
A()10
main()
end of main()
~A()10
全局变量在main之前创建，main之后销毁
*/class A{
private:
int i;
public:
A(int li):i(li){
cout << "A()" << i << endl;
}
~A(){
cout << "~A()" << i << endl;
}
};
A a(10);
void f(){
A aa(11);
}
int main(){
cout << "main()" << endl;
f();
cout << "end of main()" << endl;
}
/*
输出：
A()10
main()
A()11
~A()11
end of main()
~A()10
*/如果f()是static
class A{
private:
int i;
public:
A(int li):i(li){
cout << "A()" << i << endl;
}
~A(){
cout << "~A()" << i << endl;
}
};
A a(10);
void f(){
static A aa(11);
}
int main(){
cout << "main()" << endl;
f();
cout << "-----" << endl;
f();
cout << "end of main()" << endl;
}
/*
输出：
A()10
main()
A()11
--------
end of main()
~A()11
~A()10
第一次调用f()时才构造aa，aa的析构发生在main函数结束，并且第二次调用函数时不会再构造aa
*/Static applied to objects ...
• Construction occurs when definition is encountered
–Constructor called at-most once
–The constructor arguments must be satisfied
• Destruction takes place on exit from program
–Compiler assures LIFO order of destructors
Conditional construction
• Example: conditional construction
void f(int x) {
if (x > 10) {
static X my_X(x, x * 21);
...
}•my_X
–is constructed once, if f() is ever called with x > 10
–retains its value
–destroyed only if constructed
Global objects
• Consider
#include "X.h"
X global_x(12, 34);
X global_x2(8, 16);• Constructors are called before main() is entered
–Order controlled by appearance in file
– In this case, global_x before global_x2
– main() is no longer the first function called
• Destructors called when
–main() exits
–exit() is called
Static Initialization Dependency
• Order of construction within a file is known
• Order between files is unspecified!
• Problem when non-local static objects in different files
have dependencies.
• A non-local static object is:
–defined at global or namespace scope
–declared static in a class
–defined static at file scope
x2的构造需要x1，但两个在不同的文件，跨编译单元无法保证构造顺序
Static Initialization Solutions
• Just say no -- avoid non-local static dependencies.
• Put static object definitions in a single file in correct order.
Can we apply static to members?
• Static means
–Hidden
–Persistent
• Hidden: A static member is a member
–Obeys usual access rules
• Persistent: Independent of instances
• Static members are class-wide
–variables or
–functions
class A{
private:
int i;
static int s;
public:
A(int li):i(li){
s = 0;
cout << "A()" << i << endl;
}
~A(){
cout << "~A()" << i << endl;
}
void setS(int k){s = k;}
int getS() const{return s;}
};
int A::s = 0;//需要写这个定义，因为静态成员变量相当于全局变量，不写出现链接错误，但是定义前面不能写static，因为要在其他的文件使用A类。
int main(){
A a1(10);
A a1(20);
cout << a2,getS() << endl;
a1.setS(11);
cout << a2,getS() << endl;
}
/*
输出：
A()10
A()20
0
11 //a2打印s是11。说明静态成员变量在所有对象中共享，实际上是因为静态成员变量属于特殊的全局变量
~A()20
~A()10
*/静态成员变量在.h的类中声明，一定要注意在.cpp中写定义
Static members
• Static member variables
–Global to all class member functions
–Initialized once, at file scope
–provide a place for this variable and init it in .cpp
–No ‘static’ in .cpp
• Example: StatMem.h, StatMem.cpp
• Static member functions
–Have no implicit receiver ("this")
• (why?)
–Can access only static member variables
• (or other globals)
–No ‘static’ in .cpp
–Can’t be dynamically overridden
• Example: StatFun.h, StatFun.cpp
To use static members
• <class name>::<static member>
• <object variable>.<static member>
NameSpace
Controlling names:
• Controlling names through scoping
• We’ve done this kind of name control:
class Marbles {
enum Colors { Blue, Red, Green };
...
};
class Candy {
enum Colors { Blue, Red, Green };
...
};Avoiding name clashes
• Including duplicate names at global scope is a problem:
// old1.h
void f();
void g();
// old2.h
void f();
void g();Avoiding name clashes (cont)
• Wrap declarations in namespaces.
// old1.h
namespace old1 {
void f();
void g();
}
// old2.h
namespace old2 {
void f();
void g();
}Namespace
• Expresses a logical grouping of classes, functions, variables, etc.
• A namespace is a scope just like a class
• Preferred when only name encapsulation is
needed
namespace Math {
double abs(double );
double sqrt(double );
int trunc(double);
...
} // Note: No terminating end colon!Defining namespaces
• Place namespaces in include files:
// Mylib.h
namespace MyLib {
void foo();
class Cat {
public:
void Meow();
};
}Defining namespace functions
• Use normal scoping to implement functions in
namespaces.
// MyLib.cpp
#include ”MyLib.h”
void MyLib::foo() { cout << "foo\n"; }
void MyLib::Cat::Meow() { cout << "meow\n"; }Using names from a namespace
• Use scope resolution to qualify names from a namespace.
• Can be tedious and distracting.
#include ”MyLib.h”
void main(){
MyLib::foo();
MyLib::Cat c;
c.Meow();
}Using-Declarations
• Introduces a local synonym for name
• States in one place where a name comes
from.
• Eliminates redundant scope qualification:
void main() {
using MyLib::foo;
using MyLib::Cat;
foo();
Cat c;
c.Meow();
}Using-Directives
• Makes all names from a namespace available.
• Can be used as a notational convenience.
void main() {
using namespace std;
using namespace MyLib;
foo();
Cat c;
c.Meow();
cout << “hello” << endl;
}Ambiguities
• Using-directives may create potential ambiguities.
• Consider:
// Mylib.h
namespace XLib {
void x();
void y();
}
namespace YLib {
void y();
void z();
}Ambiguities (cont)
• Using-directives only make the names
available.
• Ambiguities arise only when you make calls.
• Use scope resolution to resolve.
void main() {
using namespace XLib;
using namespace YLib;
x(); // OK
y(); // Error: ambiguous
XLib::y(); // OK, resolves to XLib
z(); // OK
}Namespace aliases
• Namespace names that are too short may clash
• names that are too long are hard to work with
• Use aliasing to create workable names
• Aliasing can be used to version libraries.
namespace supercalifragilistic {
void f();
}
namespace short = supercalifragilistic;
short::f();Namespace composition
• Compose new namespaces using names from other
ones.
• Using-declarations can resolve potential clashes.
• Explicitly defined functions take precedence.
namespace first {
void x();
void y();
}
namespace second {
void y();
void z();
}
namespace mine {
using namespace first;
using namespace second;
using first::y(); // resolve clashes to first::x()
void mystuff();
...
}Namespace selection
• Compose namespaces by selecting a few
features from other namespaces.
• Choose only the names you want rather than
all.
• Changes to “orig” declaration become
reflected in “mine”.
namespace mine {
using orig::Cat; // use Cat class from orig
void x();
void y();
}Namespaces are open
• Multiple namespace declarations add to the
same namespace.
–Namespace can be distributed across multiple files.
//header1.h
namespace X {
void f();
}
// header2.h
namespace X {
void g(); // X how has f() and g();
}
![[CSS案例二]—实现一个响应式网页，兼容PC移动端，ScrollReveal 增加动画](https://img-blog.csdnimg.cn/img_convert/9ea6d116e5ea4f239463cdd3d7d9b71a.png)
