C++重点笔记static和const关键字（二）

粟米是西米米

已于 2023-03-16 19:36:03 修改

阅读量62

点赞数

文章标签： c++ 算法开发语言 c语言

于 2023-03-14 20:22:54 首次发布

本文链接：https://blog.csdn.net/2201_76064374/article/details/129536905

版权

1.static关键字

1.static在c语言中的用法

static修饰局部变量：修改了局部变量的生命周期，直到程序结束。
static修饰全局变量：限制了全局变量的作用域，本文件中使用。
static修饰函数：静态函数只能在本文件中调用。

2.static在c++中的用法

1.static修饰成员变量

#include <iostream>
        using namespace std;
        class Demo{
            public:
                Demo(int val=0) //构造函数
                {
                    this->myval = val;
                    cout << __LINE__ << ":" << __func__ << endl;
                }
                Demo(const Demo &obj)//拷贝构造函数
                {
                    this->myval = obj.myval;
                    cout << __LINE__ << ":" << __func__ << endl;
                }
                ~Demo()
                {
                    cout << __LINE__ << ":" << __func__ << endl;
                }
            public:
                void setmyval(int val); //声明
                int getmyval();//声明
                static int getval() //static方法
                {
                    //return this->val; //static成员函数没有this指针
                    return val;
                }
                static int *getAddr()
                {
                    return &val;
                }
            private:
                static int val; //static成员变量
                int myval;
        };
        int Demo::val = 321;// 声明定义初始化
        void Demo::setmyval(int val)
        {
            this->myval = val;
        }
        int Demo::getmyval()
        {
            return this->myval;
        }
        int main()
        {
            Demo obj(123);
            Demo obj1;
            cout << sizeof obj << endl;
            obj.setmyval(666);
            cout << obj.getmyval() << endl;
            cout << Demo::getval() << endl;//static成员函数的访问 类名::方法名();
            cout << obj.getval() << endl;
			//所有类对象共享类的static成员
            cout << obj.getAddr() << endl;
            cout << obj1.getAddr() << endl;
            return 0;
        }
        输出
14:Demo
14:Demo
4
666
321
321
0x55a375de7010
0x55a375de7010
23:~Demo
23:~Demo

1.static修饰的成员变量称为静态成员变量，也称为类变量，它不属于某一个对象，而是由所有对象共享的。
2.静态变量存储在方法区，并且只有一份，所以我们在创建静态成员变量时可以给它就地初始化。
3.静态成员变量既可以通过对象访问，也可以通过类名访问，但一般使用类名访问。
4.生命周期伴随类的一生，随类的创建而创建，随类的销毁而销毁。

2.static修饰成员方法

1.static修饰的成员方法称为静态成员方法，又称类方法，它也不是某个对象所特有的。
2.比起普通的成员方法，静态成员方法只是多了个static的修饰。静态成员方法不能直接访问非静态成员变量和非静态成员方法。
3. 因为静态成员方法属于类，不依赖于对象，而非静态成员变量和非静态成员方法依赖于对象，要想在静态成员方法中访问非静态成员对象和非静态成员方法，需要先在方法中创建一个对象才可以访问
总结：
（1）静态成员方法不属于某个具体的对象，是类方法；
（2）可以通过对象调用，也可以通过类名调用，一般使用类名调用；
（3）不能在静态成员方法中直接访问任何非静态成员变量；
（4）不能在静态成员方法中直接调用任何非静态成员方法；

3.最后

static关键字最基本的用法是：

被static修饰的变量属于类变量，可以通过类名.变量名直接引用，而不需要new出一个类来
被static修饰的方法属于类方法，可以通过类名.方法名直接引用，而不需要new出一个类来
被static修饰的变量，被static修饰的方法是类的静态资源，是类实例间共享的，也就是说，一处变，处处变。
在C++中，静态成员属于整个类而不是某个对象，静态成员变量只存储一份供所有对象共用。所以在所有对象中都可以共享它。使用静态成员变量可以实现多个变量之间共享数据不会破坏隐藏的原则，保证了安全性还可以节省内存
静态成员的定义或声明要加个关键字static。
静态成员可以通过双冒号来使用即 <类名>::<静态成员名>。

2.const关键字

1.在C语言中的用法

1)const修饰变量:只读变量只能初始化，不能被赋值
eg:
const int a = 123;
a = 321;//error
2)const修饰指针
1.const 数据类型 *指针变量名; //等价：数据类型 const *指针变量名; 不能通过指针修改指针指向的内容
eg:
int a = 123;
int b;
const int *p = &a; //等价：int const *p;
*p = 321;//error
p = &b;//right

2.数据类型 * const 指针变量名;//指针的指向不能被修改
eg:
int a = 123;
int b;
int * const p = &a;
*p = 321;//right
p = &b; //error

3.const 数据类型 * const 指针变量名;//不能通过指针修改指针指向的内容，也不能修改指针的指向
eg:
int a = 123;
int b;
const int * const p = &a;
*p = 321;//error
p = &b; //error

2.在c++中的用法

1.const修饰成员变量

成员变量只能通过初始化列表初始化，不能被修改。
const修改全局变量是存储在全局区（即静态存储区），修饰局部变量时存储在栈区，const修饰的对象一旦创建后其值便不能再改变，类的数据成员只是声明，如果const修饰类的数据成员，那么必须要有构造函数来初始化这个const对象，其他情况必须在声明的地方就初始化。

 #include <iostream>
 using namespace std;
            class Demo{
                public:
                    Demo(int val=0,int val1=0) : cval(val),myval(val1)    //构造函数
                    {
                        //cval = val;//error const成员变量只能初始化
                        cout << __LINE__ << ":" << __func__ << endl;
                    }
                    Demo(const Demo &obj) :cval(666) //拷贝构造函数
                    {
                        this->myval = obj.myval;
                        cout << __LINE__ << ":" << __func__ << endl;
                    }
                    ~Demo()
                    {
                        cout << __LINE__ << ":" << __func__ << endl;
                    }
                public:
                    void setmyval(int val); //声明
                    int getmyval();//声明
                    int getcval()
                    {
                        return this->cval;
                    }
                    static int getval() //static方法
                    {
                        return val;
                    }
                    static int *getAddr()
                    {
                        return &val;
                    }
                private:
                    static int val; //static成员变量
                    int myval;
                    const int cval; //const成员变量: 只能初始化
            };
            int Demo::val = 321;// 声明定义初始化

            void Demo::setmyval(int val)
            {
                this->myval = val;
            }
            int Demo::getmyval()
            {
                return this->myval;
            }
            int main()
            {
                Demo obj(123);
                obj.setmyval(666);
                cout << obj.getmyval() << endl;
                cout << obj.getcval() << endl;
                return 0;
            }
            输出
14:Demo
666
123
23:~Demo

2.const修饰成员方法

特点：
a.不能通过const方法修改类对象
b.不能通过const方法调用非const方法
c.const方法可以修改static成员

#include <iostream>
using namespace std;
            class Demo{
                public:
                    Demo(int val=0,int val1=0) : cval(val),myval(val1)    //构造函数
                    {
                        //cval = val;//error const成员变量只能初始化
                        cout << __LINE__ << ":" << __func__ << endl;
                    }
                    Demo(const Demo &obj) :cval(666) //拷贝构造函数
                    {
                        this->myval = obj.myval;
                        cout << __LINE__ << ":" << __func__ << endl;
                    }
                    ~Demo()
                    {
                        cout << __LINE__ << ":" << __func__ << endl;
                    }
                public:
                    void setmyval(int val); //声明
                    int getmyval() const;//声明
                    int getcval() const
                    {
                        //myval++;//error         const方法不能修改类对象
                        //setmyval(666);//error   const方法不能调用非const方法
                        val++;//right   val是static成员，不属于类对象
                        return this->cval;
                    }
                    static int getval() //static方法
                    {
                        return val;
                    }
                    static int *getAddr()
                    {
                        return &val;
                    }
                private:
                    static int val; //static成员变量
                    int myval;
                    const int cval; //const成员变量: 只能通过初始化列表初始化
            };
            int Demo::val = 321;// 声明定义初始化
            void Demo::setmyval(int val)
            {
                this->myval = val;
            }
            int Demo::getmyval() const //const方法
            {
                return this->myval;
            }
            int main()
            {
                Demo obj(123);
                obj.setmyval(666);
                cout << obj.getmyval() << endl;
                cout << obj.getcval() << endl;
                return 0;
            }
输出
14:Demo
666
123
23:~Demo

3.const修饰对象

表示对象是只读的，不能被修改
结论：
a.const对象不能调用非const方法；
b.const对象可以调用const方法;
c.const对象可以调用static方法;

 #include <iostream>
 using namespace std;
            class Demo{
                public:
                    Demo(int val=0,int val1=0) : cval(val),myval(val1)    //构造函数
                    {
                        //cval = val;//error const成员变量只能初始化
                        cout << __LINE__ << ":" << __func__ << endl;
                    }
                    Demo(const Demo &obj) :cval(666) //拷贝构造函数
                    {
                        this->myval = obj.myval;
                        cout << __LINE__ << ":" << __func__ << endl;
                    }
                    ~Demo()
                    {
                        cout << __LINE__ << ":" << __func__ << endl;
                    }
                public:
                    void setmyval(int val); //声明
                    int getmyval() const;//声明
                    int getcval() const
                    {
                        //myval++;//error         const方法不能修改类对象
                        //setmyval(666);//error   const方法不能调用非const方法
                        val++;//right   val是static成员，不属于类对象
                        return this->cval;
                    }
                    static int getval() //static方法
                    {
                        return val;
                    }
                    static int *getAddr()
                    {
                        return &val;
                    }
                private:
                    static int val; //static成员变量
                    int myval;
                    const int cval; //const成员变量: 只能通过初始化列表初始化
            };
            int Demo::val = 321;// 声明定义初始化
            void Demo::setmyval(int val)
            {
                this->myval = val;
            }
            int Demo::getmyval() const //const方法
            {
                return this->myval;
            }
            int main()
            {
                const Demo obj(123);//const对象
                //obj.setmyval(666);//error   不能通过const对象调用非const方法
                cout << obj.getmyval() << endl;//right const对象可以调用const方法
                cout << obj.getcval() << endl;
                cout << obj.getval() << endl;//const对象可以调用static方法
                return 0;
            }
输出
14:Demo
0
123
322
23:~Demo

粟米是西米米

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++重点笔记static和const关键字（二）

static关键字最基本的用法是：被static修饰的变量属于类变量，可以通过类名.变量名直接引用，而不需要new出一个类来被static修饰的方法属于类方法，可以通过类名.方法名直接引用，而不需要new出一个类来被static修饰的变量，被static修饰的方法是类的静态资源，是类实例间共享的，也就是说，一处变，处处变。在C++中，静态成员属于整个类而不是某个对象，静态成员变量只存储一份供所有对象共用。所以在所有对象中都可以共享它。
复制链接

扫一扫