String类型_static成员_动态内存分配_拷贝构造函数_const关键字_友元函数与友元类

1：String类型

 #include <iostream>
 using namespace std;
 int main()
 {
     //初始化方法
     string s1 = "hello";//默认构造方法
     string s2(s1);//将s2初始化为s1的一个副本
     string s3("value");//将s3初始化为字符串的副本
     string s4(,'x');//将字符串初始化为字符x的10个副本
     cout << s1 << "\t" << s2 << "\t" << s3 << "\t" << s4 << "\t" << endl;
     //hello   hello   value   xxxxxxxxxx
     //string操作

     cout << s1.empty() << endl;//判断字符串是否为空
     cout << s1.size() << endl;//字符串大小
     cout << s1[] << endl;//字符串的第0个字符
     cout << s1 + s3 << endl;//拼接
     cout << (s1 == s2) << endl;//判断是否相同
     s1 = s3;//赋值
     cout << (s1 == s2) << endl;

     return ;
 }

2：static成员

关于static的详细内容可看这篇博客：C++中static关键字作用总结

总的来说static有四个主要作用：

1：隐藏。（static函数，static变量均可）

 A.cpp
 #include <bits/stdc++.h>
 using namespace std;
 char a = 'A';//加上static可以实现对变量a的数据隐藏
 void show()//加上static可以实现对函数show的数据隐藏
 {
     cout << "我来自A.cpp文件，是一个全局函数" << endl;
 }

 main.cpp
 #include <iostream>
 using namespace std;
 int main()
 {
     /*
     由于编译是对单个的文件进行编译，所以在编译一个a.cpp文件的时候，
     若是要在a.cpp中使用b.cpp中的变量，直接使用则编译肯定会报错的，
     所以这个时候应该永extern修饰在a.cpp中所使用的b.cpp中的变量，
     这个时候编译器会忽略这个错误，直到链接的时候("将文件融为一体")
     会找到b.cpp中的变量，这样便ok了。extern的作用相当于让编译器在编译
     阶段忽略这个错误
      extern 的用法可以参考  https://blog.csdn.net/pql925/article/details/82178476
     */
     extern char a;//声明要引用的变量的名称
     cout << a<< endl;//a是全局变量，可以在不同文件里面引用
     extern int show();//声明要引用的方法的名称。
     show();//show是全局函数，可以在不同文件里面引用
     return ;
 }

2: 保持变量内容的持久。（static变量中的记忆功能和全局生存期）

 #include <iostream>
 using namespace std;
 void show()
 {
     static int  a = ;//a只能被初始化一次，其他的初始化无效
     a--;
     cout << a <<"\t" ;
 }
 int main()
 {
     for(int i = ; i < ;i++)
     {
         show();
     }//9       8       7       6       5       4       3       2       1       0
     return ;
 }

3: static的第三个作用是默认初始化为0（static变量）

 #include <iostream>
 using namespace std;
 void show()
 {
     static int  a;//默认为0
     cout << a <<"\t" ;//
 }
 int main()
 {
     show();
     return ;
 }

4: 类的静态成员函数是属于整个类而非类的对象，所以它没有this指针，这就导致 了它仅能访问类的静态数据和静态成员函数。

  public:
         void static show()
         {
             height = ;//静态方法里只能有静态成员或函数
             age = ;//报错。。
         }
     protected:

     private:
         string color;
         int age;
         static int height;

3：动态内存分配

malloc在堆上分配的内存块，使用free释放内存，而new所申请的内存则是在自由存储区上，使用delete来释放

相关内存分配知识可看一下这几篇博客：

https://blog.csdn.net/questionhahaha/article/details/89462925

https://blog.csdn.net/ladybai/article/details/51234300

https://blog.csdn.net/qq_40416052/article/details/82493916

4：拷贝构造函数

强烈推荐看一下这个博主写的拷贝构造函数，很全面

关于拷贝构造函数和赋值运算符之前的区别和联系（点我）

5：const关键字

 #include <bits/stdc++.h>
 using namespace std ;

 int main()
 {
     const int a = ;
     //a = 2;            //报错，a是只读的
     int b = ;

     const int *p = &a;
     //*p = 2;            //报错，const在*左边，指针所指的值不可以直接修改。
     p = &b;             //正确，const在*左边可以修改指针所指的地址

     int* const p2 = &b;
     *p2 = ;             //正确，const在*右边可以修改指针的值
      //p2 = &b;           //错误，const在*右边不可以修改指针所指的地址

     return ;
 }

 #include <bits/stdc++.h>
 using namespace std ;
 class Data{
 public:
     Data():SIZE()//const变量要进行初始化列表
     {
         val = ;
     }
     int getValue() const
     {
         //int val++;            //报错，const声明的函数，局部变量不能修改。
         return val;
     }
 private:
     const int SIZE;
     int val;
 };
 int main()
 {
     Data data;
     cout << data.getValue();
     return ;
 }

后一个效率更高，避免了一次拷贝构造

关于const的详细总结可以参考这篇博客

6：友元函数与友元类

这篇博客有较详细的总结