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

1：String类型

 1 #include <iostream>
 2 using namespace std;
 3 int main()
 4 {
 5     //初始化方法
 6     string s1 = "hello";//默认构造方法
 7     string s2(s1);//将s2初始化为s1的一个副本
 8     string s3("value");//将s3初始化为字符串的副本
 9     string s4(10,‘x‘);//将字符串初始化为字符x的10个副本
10     cout << s1 << "\t" << s2 << "\t" << s3 << "\t" << s4 << "\t" << endl;
11     //hello   hello   value   xxxxxxxxxx
12     //string操作
13
14     cout << s1.empty() << endl;//判断字符串是否为空
15     cout << s1.size() << endl;//字符串大小
16     cout << s1[0] << endl;//字符串的第0个字符
17     cout << s1 + s3 << endl;//拼接
18     cout << (s1 == s2) << endl;//判断是否相同
19     s1 = s3;//赋值
20     cout << (s1 == s2) << endl;
21
22     return 0;
23 }

2：static成员

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

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

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

 1 A.cpp
 2 #include <bits/stdc++.h>
 3 using namespace std;
 4 char a = ‘A‘;//加上static可以实现对变量a的数据隐藏
 5 void show()//加上static可以实现对函数show的数据隐藏
 6 {
 7     cout << "我来自A.cpp文件，是一个全局函数" << endl;
 8 }
 9
10
11 main.cpp
12 #include <iostream>
13 using namespace std;
14 int main()
15 {
16     /*
17     由于编译是对单个的文件进行编译，所以在编译一个a.cpp文件的时候，
18     若是要在a.cpp中使用b.cpp中的变量，直接使用则编译肯定会报错的，
19     所以这个时候应该永extern修饰在a.cpp中所使用的b.cpp中的变量，
20     这个时候编译器会忽略这个错误，直到链接的时候("将文件融为一体")
21     会找到b.cpp中的变量，这样便ok了。extern的作用相当于让编译器在编译
22     阶段忽略这个错误
23      extern 的用法可以参考  https://blog.csdn.net/pql925/article/details/82178476
24     */
25     extern char a;//声明要引用的变量的名称
26     cout << a<< endl;//a是全局变量，可以在不同文件里面引用
27     extern int show();//声明要引用的方法的名称。
28     show();//show是全局函数，可以在不同文件里面引用
29     return 0;
30 }

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

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

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

 1 #include <iostream>
 2 using namespace std;
 3 void show()
 4 {
 5     static int  a;//默认为0
 6     cout << a <<"\t" ;//0
 7 }
 8 int main()
 9 {
10     show();
11     return 0;
12 }

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

 1  public:
 2         void static show()
 3         {
 4             height = 10;//静态方法里只能有静态成员或函数
 5             age = 100;//报错。。
 6         }
 7     protected:
 8
 9     private:
10         string color;
11         int age;
12         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关键字

 1 #include <bits/stdc++.h>
 2 using namespace std ;
 3
 4 int main()
 5 {
 6     const int a = 1;
 7     //a = 2;            //报错，a是只读的
 8     int b = 0;
 9
10     const int *p = &a;
11     //*p = 2;            //报错，const在*左边，指针所指的值不可以直接修改。
12     p = &b;             //正确，const在*左边可以修改指针所指的地址
13
14     int* const p2 = &b;
15     *p2 = 2;             //正确，const在*右边可以修改指针的值
16      //p2 = &b;           //错误，const在*右边不可以修改指针所指的地址
17
18     return 0;
19 }

 1 #include <bits/stdc++.h>
 2 using namespace std ;
 3 class Data{
 4 public:
 5     Data():SIZE(0)//const变量要进行初始化列表
 6     {
 7         val = 100;
 8     }
 9     int getValue() const
10     {
11         //int val++;            //报错，const声明的函数，局部变量不能修改。
12         return val;
13     }
14 private:
15     const int SIZE;
16     int val;
17 };
18 int main()
19 {
20     Data data;
21     cout << data.getValue();
22     return 0;
23 }

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

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

6：友元函数与友元类

这篇博客有较详细的总结

原文地址：https://www.cnblogs.com/henuliulei/p/11704820.html