码迷,mamicode.com
首页 > 其他好文 > 详细

Const那些事

时间:2020-06-24 21:25:10      阅读:62      评论:0      收藏:0      [点我收藏+]

标签:输出参数   提高   自动   结合   其他   语句   防止   g++   就是   

Const那些事

const对象默认为文件局部对象

注意:非const变量默认为extern。要使const变量能够在其他文件中访问,必须在文件中显示地指定它为extern。

未被const修饰的变量在不同文件的访问
//file1.cpp
int ext; //默认为extern
//file2.cpp
#include <iostream>
extern int ext;
int main(){
	std::cout<<(ext+10)<<std::endl;
}
const常量在不同文件的访问
//file1.cpp
extern const int ext = 12;
//file2.cpp
#include <iostream>
extern const int ext;
int main(){
	std::cout<<ext<<std::endl;
}

小结:可以发现未被const修饰的变量不需要extern显示声明!而const常量需要显示声明extern,并且需要初始化!因为常量在定义后就不能被修改,所以定义时必须初始化。

指针与const

与指针相关的const有四种:

const char *a; //指向const对象的指针或指向常量的指针
char const *a; //同上

char *const a; //指向类型对象的const指针(char型常量指针)
const char* const a;//指向char型常量的char型常量指针

小结:如果const位于的左侧,则const就是用来修饰指针所指向的变量,即指针指向为常量;如果const位于的右侧,const就是修饰指针本身,即指针本身是常量。

具体使用如下:

(1)指向常量的指针

? 不能使用void*指针保存const对象的地址,必须用**const void ***类型的指针保存const对象的地址。

const int p = 10;
const void *vp = &p;
void *vp = &p; //error

? 允许把非const对象的地址赋给指向const对象的指针

const int *ptr;
int val = 3;
ptr = &val;

不能通过ptr指针来修改val的值,即使它指向的是非const对象。

不能使用指向const对象的指针修改其基础对象,然而如果该指针指向了非const对象,可以用其他方式修改其所指的对象。可以修改const指针所指向的值,但是不能通过const对象指针来进行修改

int *ptr1 = &val;
*ptr1 = 4;
cout<<*ptr<<endl;

小结:

? 对于指向常量的指针,不能通过指针来修改对象的值。也不能使用**void *指针保存const对象的地址,必须使用const void ***类型的指针保存const对象的地址。

? 允许把非const对象的地址赋值给const对象的指针,如果要修改指针所指向的对象值,必须通过其他方式修改,不能直接通过当前指针直接修改。

(2) 常量指针

const指针必须进行初始化,且const指针的值不能修改。

#include <iostream>
using namespace std;
int main(){
	int num = 0;
	int *const ptr = &num; //const指针必须初始化,并且const指针的值不能修改
	int *t = &num; //通过修改非常量指针指向的对象,完成修改常量指针指向的值的目的
	*t = 1; //t指针指向num的地址,其指向的值(num)改为1
	cout<<*ptr<<endl;  //1
}

上述修改ptr指针所指向的值,可以通过非const指针来修改。

#include <iostream>
using namespace std;
int main()
{
	const int num = 0;
	int * const ptr = &num;  //error!const int * -> int *(ptr指向一个非常量)
    //若改为const int *ptr/const int * const ptr,可正常运行
	cout<<*ptr<<endl;
}

(3)指向常量的常指针

const int p = 3;
const int * const ptr = &p;

ptr是一个const指针,指向了一个int类型的const对象。

函数中使用const

const修饰函数的返回值

(1)const int

const int func1();

(2)const int *

const int * func2();

指针指向的内容不变(func2函数返回值是一个指针,指向一个常量)

(3)int *const

int *const func2();

指针本身不可变(func2函数返回一个int类型常量指针)

const修饰函数参数

(1)传递过来的参数及指针本身在函数内不可变,无意义!

void func(const int var);  //传递过来的参数不可变
void func(int *const var); //指针本身不可变

表明参数在函数体内不能被修改,此处var本身就是形参不会改变,没有意义;包括传入的形参是指针也是一样。输入参数采用值传递,由于函数将自动产生临时变量以用于复制该参数,该输入参数本来就无需保护,所以不要加const修饰。

(2)参数指针所指内容为常量不可变

void StringCopy(char *dst, const char *src)

其中src是输入参数,dst是输出参数。给src加上const修饰后,如果函数体内的语句试图改动src的内容,编译器将指出错误,这就是加了const的作用域之一。

(3)参数为引用,为了增加效率同时防止修改

void func(const A &a);

对于非内部数据类型的参数,像void func(A a)这样的声明函数注定效率比较低,因为函数体内将产生A类型的临时对象用于复制参数a,而临时对象的构造、复制、析构过程都将消耗时间。

为了提高效率,可将函数声明改为void func(A &a),因为引用传递仅借用参数别名,不产生临时对象,但它也有缺点:引用传递有可能改变参数a,这不是我门想要的,所以加const修饰。

问题:是否应将void func(int x) 改写为void func(const int &x),以便提高效率?

:完全没必要,因为内部数据类型的参数不存在构造、析构的过程,而复制也非常快,“值传递”和“引用传递”的效率几乎相当。

小结:对于非内部数据类型的输入参数,应该将“值传递”的方式改为“const 引用传递”,目的是提高效率;对于内部数据类型的输入参数,不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的,又降低了函数的可理解性。

类中使用const

在类中,任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时,不慎修改数据成员,或者调用了其他非const成员函数,编译器将报错,这无疑会提高程序的健壮性。使用const关键字声明的成员函数,称为常成员函数,只有常成员函数才有资格操作常量或者常对象,没有使用const关键字声明的成员函数不能用来操作常对象。

对于类中的const成员变量必须通过列表初始化进行初始化。

class Apple
{
private:
	int people[100];
public:
	Apple(int i);  //构造函数声明
	const int apple_number; //const数据成员
};

Apple::Apple(int i)::apple_number(i)//构造函数定义,使用列表初始化
{

}

const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数。

//apple.cpp
class Apple
{
private:
    int people[100];
public:
    Apple(int i); 
    const int apple_number;
    void take(int num) const;
    int add(int num);
    int add(int num) const;
    int getCount() const;

};
//main.cpp
#include<iostream>
#include"apple.cpp"
using namespace std;

Apple::Apple(int i):apple_number(i)
{

}
int Apple::add(int num){
    take(num);
}
int Apple::add(int num) const{
    take(num);
}
void Apple::take(int num) const
{
    cout<<"take func "<<num<<endl;
}
int Apple::getCount() const
{
    take(1);
//    add(); //error
    return apple_number;
}
int main(){
    Apple a(2);
    cout<<a.getCount()<<endl;
    a.add(10);
    const Apple b(3);
    b.add(100);
    return 0;
}
//编译: g++ -o main main.cpp apple.cpp
//结果
take func 1
2
take func 10
take func 100

除了上述的初始化const常量初始化列表方式外,也可以通过下面方法:

一:将常量定义与static结合

static const int apple_number

二:在外面初始化

const int Apple::apple_number=10;

三:如果你使用C++11进行编译,直接可以在定义处初始化

static const int apple_number=10;
//or
const int apple_number=10;

这里提到了static,下面简单的说一下:在C++中,static静态成员变量不能在类的内部初始化在类的内部只是声明,定义必须在类的外部,通常在类的实现文件中初始化。

static int ap;  //在类中声明
int Apple::ap=666 //在类实现文件中使用

Const那些事

标签:输出参数   提高   自动   结合   其他   语句   防止   g++   就是   

原文地址:https://www.cnblogs.com/ljwgis/p/13189499.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!