C++中的static函数和const函数

C++中的static函数和const函数

一、static特点

1.这样的函数只能在本文件中被调用
2.在同–源程序中其他文件可以定义同名的函数

#include <iostream>
using namespace std;
//static的作用：1). 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
//2). 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
//3). 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那
	class Std{
		public:
		Std()//构造函数
		{
			cout<<__func__<<":"<<__LINE__<<endl;
		}
		Std(const Std &obj )//拷贝构造函数
		{
			cout<<__func__<<":"<<__LINE__<<endl;
		}
		~Std()//析构函数
		{
			cout<<__func__<<":"<<__LINE__<<endl;
		}
	public:
	void setval(int val)
	{

	this->val=val;
	return;
	}
	int getval()
	{

		return this->val;
	}
	static int getmyval()//static静态变量的访问接口
	{
		return myval;
	}
	static int *myvaladdr()
	{

		return &myval;
	}
	private:
	int val;
	static int myval;//静态成员变量，类的成员，与对象无关
	};
	 int Std::myval=123;//static成员变量使用前必须在类的外部声明定义初始化

int main(int argc, char *argv[])
{
	Std obj;
	obj.setval(10);
cout<<obj.getval()<<endl;
cout<<obj.getmyval()<<endl;
cout<<Std::getmyval()<<endl;//静态成员的访问；类名::成员。
cout<<obj.myvaladdr()<<endl;
cout<<Std::myvaladdr()<<endl;//static也是类共享的
	
	return 0;
}

二.C中const关键字的用法

1)修饰变量，变量是只读变量，即变量只能初始化，不能被修改
	eg:

const int val = 123;//初始化
			val = 321;//error

2)const修饰指针

const int *p;//不能通过指针p修改p指向的内容 等价：int const *p;
		int * const p;//不能修改p的指向
		const int * const p;//既不能通过指针p修改p指向的内容，也不能修改p的指向

2.C++中const用法
1)const修饰成员变量:必须使用初始化列表初始化
例:

  #include <iostream>

    using namespace std;

    class Demo{
        public:
            Demo(int val=0,int val1=0) : val1(val1),val(val)  //使用初始化列表对成员变量val val1初始化
            {
                this->val = val;//赋值
                //this->val1 = val1; //const成员是只读的，只能初始化，不能修改
                cout << __func__ << ":" << __LINE__ << endl;
            }

            ~Demo()
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }
        public:
            void setval(int val)
            {
                this->val = val;

                return ;
            }

            int getval()
            {
               
                return this->val;
            }

            int getval1() 
            {
                return this->val1;
            }

        private:
            int val;
            const int val1;//const成员变量
			
    };


    int main()
    {

        Demo obj(123,321);
        cout << obj.getval1() << endl;

        return 0;
    }

2)const修饰成员方法: 不能通过此方法修改对象
	即：
		const方法只能调用const方法
		const方法不能调用非const方法
		const方法可以修改static成员变量
例：

#include <iostream>

using namespace std;

class Demo{
    public:
        Demo(int val=0,int val1=0) : val1(val1),val(val)  //使用初始化列表对成员变量val val1初始化 重点：不能通过初始化列表对static成员变量初始化
        {
            this->val = val;//赋值
            //this->val1 = val1; //const成员是只读的，只能初始化，不能修改
            cout << __func__ << ":" << __LINE__ << endl;
        }

        ~Demo()
        {
            cout << __func__ << ":" << __LINE__ << endl;
        }
    public:
        void setval(int val)
        {
            this->val = val;

            return ;
        }

        int getval() const  //const成员方法:不能修改类对象
        {
            //val++;//error 
            //setval(666);//error 原因：const方法不能调用非const方法，因为非const方法有可能修改类对象
            getval1();//right 原因:const方法可以调用const方法
            myval++;//right 原因:myval是static成员，不属于对象
            return this->val;
        }

        int getval1() const
        {
            return this->val1;
        }

    private:
        int val;
        const int val1;//const成员变量
		static int myval;
};
int Demo::myval = 123;

int main()
{

    Demo obj(123,321);
    cout << obj.getval1() << endl;

    return 0;
}

3)const修饰对象:表示对象是只读，即对象不能被修改
	const对象只能调用const方法
	const对象也可以调用static方法
	const对象不能调用非const方法
	
	eg:

  #include <iostream>

        using namespace std;

        class Demo{
            public:
                Demo(int val=0,int val1=0) : val1(val1) //使用初始化列表对成员变量val val1初始化
                {
                    this->val = val;//赋值
                    //this->val1 = val1; //const成员是只读的，只能初始化，不能修改
                    cout << __func__ << ":" << __LINE__ << endl;
                }

                ~Demo()
                {
                    cout << __func__ << ":" << __LINE__ << endl;
                }
            public:
                void setval(int val)
                {
                    this->val = val;

                    return ;
                }

                int getval() const  //const成员方法:不能修改类对象
                {
                    //val++;//error 
                    myval++;//right 原因:myval是static成员
                    return this->val;
                }

                int getval1() const
                {
                    return this->val1;
                }

                static int getmyval()
                {
                    return myval;
                }

            private:
                int val;
                const int val1;//const成员变量
                static int myval;//static成员

        };

        int Demo::myval = 123;

        int main()
        {

            const Demo obj;//const对象

            //obj.setval(666);//error obj是const对象，只能调用const方法

            cout << obj.getval() << endl;//right const对象可以调用const方法
            cout << obj.getmyval() << endl;//right getmyval()是static方法，是类的成员

            return 0;
        }