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(10,'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[0] << endl;//字符串的第0个字符
    cout << s1 + s3 << endl;//拼接
    cout << (s1 == s2) << endl;//判断是否相同
    s1 = s3;//赋值
    cout << (s1 == s2) << endl;

    return 0;
}

 

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 0;
}

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

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

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

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

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

 public:
        void static show()
        {
            height = 10;//静态方法里只能有静态成员或函数
            age = 100;//报错。。
        }
    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 = 1;
    //a = 2;            //报错，a是只读的
    int b = 0;

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

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

    return 0;
}

 

 

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

 

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

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

6：友元函数与友元类

 

 

 

这篇博客有较详细的总结