C++整理笔记一览（建议收藏）

1. cstring与string的区别。

(<string.h> == <cstring>)

1. 在C语言中<cstring>主要是为了使用字符串函数 在C++中<string>主要是为了使用std::string类。例如:memcmp;memcpy;memmove;strlen;
2. 在字符串声明中的区别例如：char str[20]; （C中必须声明字符串的长度） 而C++中只需要 string str;且使用一个null字符作为结尾; (C++的string类型不需要使用null)
3. 在字符串的操作方式上有所不同例如：strcpy(name,"peter"); name = "pepter"; str5 = str2 + str3; str2<str3;
4. C++的string类型不能用printf内的%s打印出来 string类中提供了c_str();通过.的方式去访问类中的c_str(),即会返回当前字符串的首地址 (char *)，就可以通过%s来打印string类型的字符串了。

2.结构体的区别

struct和class可以设定访问权限，class默认权限为私有、struct默认权限为公有；

在C++中结构体就是类：（多个事物的个体的共同属性）；

属性：（数据类型描述）+（成员函数）；

对象: 类的具体化/实例化；**

!!!当函数实现写在结构体内部时，会变为inline(内联函数)，为了使程序运行更快，但会占用更多内存，所以如果函数比较长建议类内声明，类外实现；

函数类外实现需要加作用域表示是哪个类的函数，例如：void 类名::函数名（参数列表）{};

2.1构造函数，析构函数

2.1.1构造函数

分为构造函数和拷贝构造函数：

class man{
public:
    //构造函数
    man(string name = "0",int age = 0){      //当没有参数或参数不够时，使用默认值
        this->name = name;                   //用来区别形参和数据成员同名的问题，this表示每一个对象的首地址。
        this->age = age;
    }
    //拷贝构造函数
    man(const man &p){                      //拷贝构造函数参数用const修饰，防止改动原件
        name = p.name;
        age = p.age;
    }
private:
    string name;
    int age;
};

只要创建新的对象，就会调用一次构造函数或拷贝构造函数；

默认的拷贝构造函数也可以用delete删除；

2.1.2析构函数

对象执行结束时被调用，释放内存；

如果对象创建在堆区需要手动释放（delete）才会自动调用析构函数,析构函数也需要手写delete；

穿裤子的析构顺序；

静态变量是最后被析构的；（因为静态变量最先被构造）

delete可以直接调用析构函数；

class man{
public:
    //构造函数
    man(char* name = '0',int age = 0){      
        this->name = new char(strlen(name)+1);
        strcpy(this->name,name);
        this->age = age;
    }
    //析构函数
    ~man(){
        delete[] name;
        name = nullptr;
    }
private:
    char* name;
    int age;
};

2.1.2.1深拷贝与浅拷贝

1. 浅拷贝是指初始化对象时在栈区
2. 深拷贝是指初始化对象时有成员被创建在堆区****当构造函数初始化数据，数据存放在堆区时，成员初始化完成调用析构函数时，堆区的内存被重复释放。此时需要通过深拷贝来解决问题。

class man{
public: //构造函数
man(char* name = '0',int age = 0){
this->name = new char(strlen(name)+1);
strcpy(this->name,name);
this->age = age;
} //深拷贝构造函数
man(const man &p){ //拷贝构造函数参数用const修饰，防止改动原件；
name = new char(*p.name); //name = new char[strlen(p.name)+1];strcpy(name,p.name);
age = p.age; //new() 分配这种类型的一个大小的内存空间,并以括号中的值来初始化这个变量;
} //new[] 分配这种类型的n个大小的内存空间,并用默认构造函数来初始化这些变量;
//析构函数
~man(){ delete[] name; name = nullptr;
}private: char* name; int age;};

2.2初始化对象

2.2.1构造函数初始化

构造函数没有返回值类型；

函数名和类名相同；

可以函数重载；

如果没有创建构造函数，会自动创建一个构造函数；

可以通过 类名（） = delete； 的方式删除默认的构造函数；

不需要自己调用，只要创建对象就会调用相应的构造函数；

一般情况默认的构造函数是公有类型；

struct Girl {
    string name;
    int age;
    Girl(string sName, int sAge)  {
        name = sName;
        age = sAge;
    }
};

    Girl MM_1("墨菲特", 18);

struct Girl {
    string name;
    int age;
    //初始化参数列表写法
    Girl(string sName, int sAge) :name(name),age(age) {}
};

2.2.2引用初始化

struct Girl {
    string name;
    int age;
    string& getname(){
        return name;
    }
    int& getage(){
        return age;
    }
};
    Girl MM_1;
    MM_1.getname() = "墨菲特";
    MM_1.getage() = 18;

3.特殊成员

3.1const成员

1. const 数据成员只能采用初始化参数列表的方式进行初始化；构造函数必须要初始化常数据成员；

class peple{
public:
    peple() :age(0){}
private:
    const int age;
};

const 成员函数const放在函数 ）后面；函数内是不能对数据成员修改的，只能读；常成员函数可以和普通函数共存

void print_age(){}              //常成员函数可以和普通函数共存
void print_age() const
{
    //函数内是不能对数据成员修改的，只能读
    cout<< age <<endl;
}

1. const 对象常对象只能调用常成员函数普通对象优先调用普通函数

const peple  man("墨菲特");    //只能调用常成员函数

3.2static成员

1. static数据成员相当于写在类中的全局变量；声明需要前缀，并且必须在类外进行初始化，类外初始化不需要static前缀；依旧受权限限定词限定；使用可以不需要对象，静态数据成员属于类，不属于变量；
2. static成员函数声明需要前缀，并且必须在类外进行初始化，类外初始化不需要static前缀；访问静态数据成员，调用不需要对象；访问非静态数据成员，需要指定对象（函数参数需要对象）；静态函数的调用不需要对象；

class peple{
public:
    static void print_age();
private
    static int age;
}
peple::age = 18;
void peple::print_age(){
    cout<<age<<endl;
};

4.友元

1. 友元函数在函数前使用friend修饰；在类中声明，在类外实现不需要作用域以及friend修饰词；在当前函数中赋予对象具有打破类的权限限定；

class MM {
    friend void makeBoyFriend();
public:
    MM(string name, int age, int money) :name(name), age(age), money(money) {}
private:
    string name;
    int age;
    int money;
};
void makeBoyFriend() {
    MM boy("yykk", 18, 100);
    cout << boy.name << ":" << boy.age << boy.money << endl;
}

1. 友元类在当前类的任何地方girl对象都可以访问girl任何属性；

class A{
    friend class b;
};

5.类的组合

将一个其他类作为自身类的成员；

1. 组合出来的类必须以初始化参数列表方式调用被组合类的构造函数

class Cloths {
public:
    ////通过缺省的方式写，下面组合类（MM）就不需要用初始化参数列表写被组合类的构造函数了
    Cloths(int color = 0) :color(color) {}  
protected:
    int color;
};
class Cosmetics {
public:
    Cosmetics(int moeny = 0) :money(money) {}
protected:
    int money;
};
class MM {
public:
    //组合出来的类必须以初始化参数列表方式调用被组合类的构造函数
    MM(string name, int color, int money) :Cosmetic1(money), Cloth1(color) { 
        this->name = name;
    }
protected:
    string name;
    //构造被组合的类的构造函数顺序和这个声明顺序有关
    Cloths Cloth1;
    Cosmetics Cosmetic1;
};

C语言C++编程学习交流圈子 点击此处一起来学习

有一些源码和资料分享，欢迎转行也学习编程的伙伴，和大家一起交流成长会比自己琢磨更快哦！