C++之对象的使用

码农世界 2024-05-29 前端 109 次浏览 0个评论

1、static成员

2、static成员优点

2、static成员函数

静态成员函数不能访问非静态成员原因：因为没有this指针。也不可以访问非静态成员函数。

可以通过对象来访问静态成员，但是不推荐这么使用，会让人误解成这个x_是属于对象的，但是静态成员是属于类的。

3、类/对象大小计算

一个虚函数，会增加4个字节，因为增加了一个虚函数表指针。

4、四种对象的作用域与生存期

bss区，即block started by symbol，因为未初始化的数据，在可执行文件中不占用空间，因为他们的初始值都为0，既然等于0，我们只需要一个符号来表示即可，不需要再为它们分配空间。

5、static用法总结

6、static与单例模式

禁止拷贝：将拷贝构造函数和等号运算符声明为私有的，这样就不允许拷贝和赋值

#include 
using namespace std
class Singleton
{
public:
    static Singleton* GetInstance()
    {
        if(instacne_== NULL)
        {
            instacne_= new Singleton;
        }
        return instacne_
    }
    
    ~Singleton()
    {
        cout<<"Singleton"< 
 
还有就是：在构造函数中，开辟的内存，在单例的这个对象生命周期结束的时候自动释放 
方法一：提供一个释放内存的方法，主动调用 
#include 
using namespace std
class Singleton
{
public:
    static Singleton* GetInstance()
    {
        if(instacne_== NULL)
        {
            instacne_= new Singleton;
        }
        return instacne_
    }
    
    ~Singleton()
    {
        cout<<"Singleton..."< 
但是这样缺点也很明显：如果一个程序很多地方都使用了一个单例的对象，我们要释放，要在哪里释放？这个就不好控制了。我们需要的是在这个对象的声明周期结束的时候自动释放。 
方法二：提供一个内嵌的嵌套类，然后再定义一个嵌套类的对象，当该单例对象的声明周期结束的时候，这个嵌套类的对象也就释放了。 
#include 
using namespace std
class Singleton
{
public:
    static Singleton* GetInstance()
    {
        if(instance_== NULL)
        {
            instance_= new Singleton;
        }
        return instance_
    }
    
    ~Singleton()
    {
        cout<<”Singleton'< 
但是这样的情况下在类中又嵌套了一个类，看起来还是不美观。 
方法三：auto_ptr智能指针，这个等后期再讲 
方法四：这边是利用了一个static的特性，如果你第二次调用的话，那就不会再重新生成一个static对象，会用原来的。而且是一个局部静态对象，当程序结束的时候，就会调用析构函数销毁。但是这样，不是线程安全的。 
#include 
using namespace std
class Singleton
{
public:
    static Singleton& GetInstance()
    {
        static Singleton instance;
        return instance;
    }
    
    ~Singleton()
    {
        cout<<"~Singleton..."< 
7、const成员函数 
 
const也可以构成重载。 
#include 
using namespace std;
class Test
{
public:
    Test(int x):x_(x)
    {
        
    }
    int GetX() const
    {
        cout << "const GetX ..." << endl;
        //x_ = 100;  // 这样会报错
        return x_;
    }
    int GetX()
    {
        cout << "GetX ..." << endl;
        return x_;
    }
private:
    int x_;
}
int main(void)
{
    return 0;
} 
8、const对象 
因为const对象不允许修改，所以如果const对象允许调用非const成员函数，那就有被修改的风险。 
#include 
using namespace std;
class Test
{
public:
    Test(int x):x_(x)
    {
        
    }
    int GetX() const
    {
        cout << "const GetX ..." << endl;
        //x_ = 100;  // 这样会报错
        return x_;
    }
    int GetX()
    {
        cout << "GetX ..." << endl;
        return x_;
    }
private:
    int x_;
}
int main(void)
{
    const Test t(10);
    t.GetX();
    Test t2(20);
    t2.GetX();
    return 0;
} 
 
9、mutable 
 
#include 
using namespace std;
class Test
{
public:
    Test(int x):x_(x)
    {
        
    }
    int GetX() const
    {
        cout << "const GetX ..." << endl;
        //x_ = 100;  // 这样会报错
        return x_;
    }
    int GetX()
    {
        cout << "GetX ..." << endl;
        return x_;
    }
    void OutPut() const
    {
        cout << "x = " << x_ << endl;
        outputTimes_++;
    }
    int GetOutputTimes() const
    {
        return outputTimes_;
    }
private:
    int x_;
    mutable int outputTimes_;
}
int main(void)
{
    const Test t(10);
    t.GetX();
    Test t2(20);
    t2.GetX();
    t.Output();
    t.Output();
    cout << t.GetOutputTimes() << endl;
    return 0;
} 
 
10、const总结