C++——类

最新推荐文章于 2020-07-17 20:07:27 发布

weixin_30344131

最新推荐文章于 2020-07-17 20:07:27 发布

阅读量107

点赞数

文章标签： c/c++

原文链接：http://www.cnblogs.com/yrm1160029237/p/11469472.html

版权

1.类和结构体，只有的默认访问权限的区别

2.类内不能定义和类外类型名相同的类型名。为什么？typedef机制？

typedef double money;
class Account 
{
private:
    typedef double money;//❌
}

3.变量名一致时的调用（不推荐相同的变量名）

pos height;
class Screen {
void Screen::dummy_fcn(pos height);
private:
  pos cursor =0 ,height=0, width=0;  
}
void Screen::dummy_fcn(pos height)
{
  cursor=width*height;//传入参数  
    cursor=width*this->height;//成员
  cursor=width*Screen::height;//成员
  cursor=width*::height;//全局变量
}

4.初始化和赋值的区别

class ConstRef{
public:
    ConstRef(int ii);
private:
  int I;
  const int ci;
  int &ri;      
}
ConstRef:: ConstRef(int ii){
  I=ii;
  ci=ii;//错误
  ri=i;      //错误
}

ConstRef:: ConstRef(int ii)：I（ii）,ci(ii), ri(i) { }//正确

5.初始化列表的顺序与参数定义的顺序一致

class X {
    int i;
    int j;
public:
    X(int val):j(val),i(j){}//本想val->j->i,实际是：j->i,val->j
}

6.默认构造函数、委托构造函数、合成的默认构造函数

class Sales_data{
    Sales_data(std::string s, unsigned int, double price): bookNo(s), units_sold(cnt), revenue(int*price) { }
    Sales_data():Sales_data(" ",0,0){ }//委托构造函数
 }

6.1 三五法则

三个控制类拷贝的基本操作：拷贝构造函数；赋值拷贝运算符；析构函数

//类值的类 
class HasPtr {
public:
    HasPtr(const std::string &s=std::string()): ps(new std::string(s)),i(0) {}//构造函数1
    HasPtr(const HasPtr &p):ps(new std::string(*p.ps)),i(p.i){}    //构造函数2
    HasPtr &operator=(const HasPtr &);//赋值拷贝运算符

    ~HasPtr() { delete ps; }//此虚构函数必须同时定义一个对应的构造函数和拷贝复制运算符

private:
    std::string *ps;
    int i;
};

需要析构函数的类也需要赋值和拷贝操作；

需要赋值操作的类也需要拷贝操作，反之亦然；

    HasPtr f(HasPtr hp)//传值，拷贝
    {
        HasPtr ret = hp;//再拷贝
        return ret;//ret和hp都被销毁
    }
    HasPtr p("something");
    f(p);//f结束，p.ps被销毁
    HasPtr q(p);//p 和 q都指向无效内存---------------->如何解决？

7.默认初始化、值初始化

7.1 默认初始化

不使用初值定义非静态变量 int i;
类成员为类类型，使用合成的默认构造函数时？
没有在构造函数中显示初始化时

7.2 值初始化

数组初始化中，提供的值数量少于数组大小
不使用初始值定义局部静态变量
通过T()显式求是初始化

8.当类只含有内置类型或复合类型的成员时，编译器是不会为类合成默认构造函数的。因为：内置类型可以有自己的默认初始化，复合类型有给出的显示的构造函数进行初始化（如果没给，而复合类型中的成员又不是内置类型，说白了，找不到初始值的话，就会报错）

8.1 B（）没有给b_member初值

8.2 去NoDefault里找初值。发现NoDefault的构造函数里也没有给初值:报错

9.聚合类

所有成员public，没有构造函数，没有类内初值，没有基类，没有virtual函数

10.字面值常量类

11.类的静态成员

静态成员可以是不完全类型，可以是类本身（指针也可以，但普通数据成员不行）
静态成员可以作为默认实参（因为可以提取值，但普通成员不行）

12.析构

析构函数不接受参数，不能被重载
隐式销毁一个内置指针类型，不会delete它所指向的对象（智能指针会？）
如果一个类需要自定义析构函数，那它也需要自定义拷贝构造函数、拷贝赋值运算符

13.阻止拷贝-delete（不用private是因为友元可以访问）

struct NoCopy {
    NoCopy() = default;    //使用合成的默认构造函数
    NoCopy(const NoCopy&) = delete;    //阻止拷贝//不要声明为private
    NoCopy &operator = (const NoCopy&) = delete;//阻止赋值//不要声明为private，成员函数、友元函数调用会出错
    ~NoCopy() =default;//如果是delete，就不能销毁其对象了 
};

类成员的析构函数是delete或private，则合成的析构函数将会是delete
------------拷贝构造------------------------，----------拷贝构造------------------
------------析构函数------------------------，----------拷贝构造------------------
------------拷贝赋值运算符是delete或private或const &，----------拷贝赋值运算符----------------
------------析构函数是delete或private，或有引用成员且没有类内初始化器，或有const成员且类型未显示定义默认构造函数，则合成的默认构造函数将会是delete
析构函数不能是delete

13.拷贝控制和资源管理：

13.1 行为像值的类：有自己的状态，完全独立。

//类值的类 
class HasPtr {
public:
    HasPtr(const std::string &s=std::string()): ps(new std::string(s)),i(0) {}//构造函数1
    HasPtr(const HasPtr &p):ps(new std::string(*p.ps)),i(p.i){}    //构造函数2
    HasPtr& operator=(const HasPtr &);//赋值拷贝运算符
    ~HasPtr() { delete ps; }//此虚构函数必须同时定义一个对应的构造函数和拷贝复制运算符
private:
    std::string *ps;
    int i;
};
HasPtr& HasPtr::operator=(const HasPtr &rhs)
{
    auto newp = new string(*rhs.ps);//为了避免rhs和*this是同一个对象
    delete ps;
    ps = newp;
    i = rhs.i;
    return *this;
}

13.2 行为像指针的类：共享状态，改变副本即改变原值。（对原值进行不同状态下的操作）

最好的办法：shared_ptr

直接管理资源：引用计数（存放在哪里——动态内存）

//类指针的类 
class HasPtr {
public:
    HasPtr(const std::string &s=std::string()): ps(new std::string(s)),i(0),use(new std::size_t(1)) {}//构造函数1
    HasPtr(const HasPtr &p) :ps(new std::string(*p.ps)), i(p.i), use(p.use) { ++*use; }    //构造函数2
    HasPtr& operator=(const HasPtr &);//赋值拷贝运算符

    ~HasPtr() {
        if (--*use == 0)
        {
            delete ps;
            delete use;
        }//此虚构函数必须同时定义一个对应的构造函数和拷贝复制运算符
    }

private:
    std::string *ps;
    int i;
    std::size_t *use;//引用计数
};
HasPtr& HasPtr::operator=(const HasPtr &rhs)
{
    ++ *rhs.use;//增加右侧对象的引用计数
    if (--*use == 0)//先减少原本对象的引用计数（可能本来是别的对象，更改之后就要把原来的减一）
    {
        delete ps;
        delete use;
    }
    //拷贝
    ps = rhs.ps;
    i = rhs.i;
    use = rhs.use;
    return *this;
}