关于指针赋值和const的疑惑

初始化 指的是在变量声明的同时，给变量赋值，这个“赋值”行动 叫 “初始化”。
例如：
double rates[5]={8899, 10012, 5945, 18311, 3405};
声明rates是double数组，有5个元素。并 把赋值号后面的一串数据赋给了rates数组， 这个“赋值”行动 就是初始化。
const doublepc=rates;
声明 pc 是 const double 型指针。并 把 赋值号后面的 rates数组 的首地址 赋给了 指针 pc。 这个“赋值”行动 就是初始化。
====
rates[] 数组 不是 const locked[] 数组 是 const 指针 pc 是 const。
pc=locked; 这是赋值语句， 让 指针 pc 指向 locked 数组 的首地址。
pc=&rates[3]; 这是赋值语句， 让 指针 pc 指向 rates[3] 数组元素 的地址。
====
const 的作用是保护数据，声明为 const 的数组元素数据，一旦初始化后它的数据就不允许改变。
例如： pc=locked; -- 指针 pc 指向 locked 数组
若有语句 pc=5; （实际意思等价于 locked[0]=5; ） 这就出错。因 const 的数组元素 ，它的数据不允许改变。

var a = "xx";全局和函数作用域变量赋值

let b = "uu" ;块级作用域变量赋值

const c = "zz";常量赋值

var [a,b,c] = [ "xx", "yy","zz"] ; 结构赋值

特点，赋值只需要"= "就可以了，不需要类型声明

counter = 100 # 赋值整型变量

miles = 10000 # 浮点型

name = "John" # 字符串

给多个变量赋值 真简单啊，靠

a = b = c = 1；

a, b, c = 1, 2, "john"

var a = "菜鸟教程"

var b string = "runoobcom"

var c bool  // 默认值是 false

var a int = 10

c := 10 // 省略var的简写， 前提是c 从未被声明过；

常量赋值

显式类型定义： const b string = "abc"

隐式类型定义： const b = "abc"  //可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

给多个变量赋值

var vname1, vname2, vname3 = v1, v2, v3；

const c_name1, c_name2 = value1, value2

int a, b, c;         // 声明三个int型整数：a、 b、c

int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值

byte z = 22;         // 声明并初始化 z

String s = "runoob"; // 声明并初始化字符串 s

double pi = 314159; // 声明了双精度浮点型变量 pi

char x = 'x';        // 声明变量 x 的值是字符 'x'。

因为在Func函数中的return a+b;返回的是一个局部变量，因此调用Func_2(Func());时，传递给Func_2的是一个局部变量的引用。而当Func函数返回后，所有局部变量都已经释放了，所以，实际上传递给Func_2函数的是一个已经释放了的变量的引用，这当然不行。
改成这样就行了：
int a=0,b=1;
static int c=a+b;
return c;

常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。因此，定义或说明常类型时必须进行初始化。
一般常量和对象常量
1 一般常量
一般常量是指简单类型的常量。这种常量在定义时，修饰符const可以用在类型说明符前，也可以用在类型说明符后。如：
int const x=2;
或
const int x=2;
定义或说明一个常数组可采用如下格式：
<类型说明符> const <数组名>[<大小>]…
或者
const <类型说明符> <数组名>[<大小>]…
例如：
int const a[5]={1, 2, 3, 4, 5};
2 常对象
常对象是指对象常量，,的rTmag教~无_;定义格式如下：
<类名> const <对象名>
或者
const <类名> <对象名>
定义常对象时，同样要进行初始化，并且该对象不能再被更新，修饰符const可以放在类名后面，也可以放在类名前面。
常指针和常引用
1 常指针
使用const修饰指针时，由于const的位置不同，而含意不同。下面举两个例子，说明它们的区别。
下面定义的一个指向字符串的常量指针：
char const prt1 = stringprt1;
其中，ptr1是一个常量指针。因此，下面赋值是非法的。
ptr1 = stringprt2;
而下面的赋值是合法的：
ptr1 = "m";
因为指针ptr1所指向的变量是可以更新的，不可更新的是常量指针ptr1所指的方向(别的字符串)。
下面定义了一个指向字符串常量的指针：
const ptr2 = stringprt1;
其中，ptr2是一个指向字符串常量的指针。ptr2所指向的字符串不能更新的，
K提教{网i^管H6L络v^
而ptr2是可以更新的。因此，
ptr2 = "x";
是非法的，而：
ptr2 = stringptr2;
是合法的。
所以，在使用const修饰指针时，L网VMXN$[m}应该注意const的位置。定义一个指向字符串的指针常量和定义一个指向字符串常量的指针时，const修饰符的位置不同，前者const放在和指针名之间，后者const放在类型说明符前。
2 常引用
使用const修饰符也可以说明引用，被说明的引用为常引用，该引用所引用的对象不能被更新。其定义格式如下：
const <类型说明符> & <引用名>
例如：
const double & v;
在实际应用中，f网|B\xc{Lf&pHhA育常指针和常引用往往用来作函数的形参，这样的参数称为常参数。
在C++面向对象的程序设计中，指针和引用使用得较多，其中使用const修饰的常指针和常引用用得更多。使用常参数则表明该函数不会更新某个参数所指向或所引用的对象，这样，在参数传递过程中就不需要执行拷贝初始化构造函数，这将会改善程序的运行效率。
下面举一例子说明常指针作函数参数的作法。
#include
const int N = 6;
void print(const int p, int n);
void main()
{
int array[N];
for (int i=0; i cin>>array[i];
print(array, N);
}
void print(const int p, int n)
{
cout<<"{"<<p;
for (int i=1; i cout<<","<<(p+i);
cout<<"}"< }
常成员函数
使用const关键字进行说明的成员函数，称为常成员函数。只有常成员函数才有资格 *** 作常量或常对象，没有使用const关键字说明的成员函数不能用来 *** 作常对象。常成员函数说明格式如下：
<类型说明符> <函数名> (<参数表>) const；
其中，const是加在函数说明后面的类型修饰符，它是函数类型的一个组成部分，因此，在函数实现部分也要带const关键字。下面举一例子说明常成员函数的特征。
#include
class R
{
public:
R(int r1, int r2) { R1=r1; R2=r2; }
void print();
void print() const;
private:
int R1, R2;
};
void R::print()
{
cout< }
void R::print() const
{
cout< }
void main()
{
R a(5, 4);
aprint();
const R b(20, 52);
bprint();
}
该例子的输出结果为：
5,4
20;52
该程序的类声明了两个成员函数，|Tv;T专tj%专I
o;(6!gG2]教bzz专"
其类型是不同的(其实就是重载成员函数)。有带const修饰符的成员函数处理const常量，这也体现出函数重载的特点。
常数据成员
类型修饰符const不仅可以说明成员函数，也可以说明数据成员。
由于const类型对象必须被初始化，并且不能更新，因此，在类中说明了const数据成员时，只能通过成员初始化列表的方式来生成构造函数对数据成员初始化。
下面通过一个例子讲述使用成员初始化列表来生成构造函数。
#include
class A
{
public:
A(int i);
void print();
const int &r;
private:
const int a;
static const int b;
};
const int A::b=10;
A::A(int i):a(i), r(a)
{
}
void A::print()
{
cout< }
void main()
{
A a1(100), a2(0);
a1print();
a2print();
}
该程序的运行结果为：
100:10:100
0:10:0
在该程序中，说明了如下三个常类型数据成员：
const int & r;
const int a;
static const int b;
其中，r是常int型引用，a是常int型变量，b是静态常int型变量。
程序中对静态数据成员b进行初始化。
值得注意的是构造函数的格式如下所示：
A(int i):a(i),r(a)
{
}
其中，冒号后边是一个数据成员初始化列表，它包含两个初始化项，用逗号进行了分隔，因为数据成员a和r都是常类型的，需要采用初始化格式。

---