C++复习笔记6

 1.String类的实现

注意深浅拷贝， C语言字符串拼接函数strcat()

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vld.h>
#include<assert.h>
using namespace std;class String
{friend ostream& operator<<(ostream & cout, const String & s);
public://String(const char* str)//处理了空指针，等效空串进行初始化//{//	if (str == nullptr)//	{//		this->m_data = (char*)malloc(sizeof(char));//		this->m_data[0] = '\0';//	}//	else//	{//		this->m_data = (char*)malloc(sizeof(char) * (strlen(str) + 1));//		strcpy(this->m_data, str);//	}//}String(const char* str = "")//等效写法 空指针和空串不同 没有处理空指针，更加严格{this->m_data = (char*)malloc(sizeof(char) * (strlen(str) + 1));strcpy(this->m_data, str);}String(const String& s){this->m_data = (char*)malloc(sizeof(char) * (strlen(s.m_data) + 1));strcpy(this->m_data, s.m_data);}String& operator=(const String& s){if (this != &s){free(this->m_data);this->m_data = (char*)malloc(sizeof(char) * (strlen(s.m_data) + 1));strcpy(this->m_data, s.m_data);}return *this;}int Length() const{return strlen(this->m_data);}String operator+(const String& s){String tmp(*this);tmp += s;return tmp;}String& operator+=(const String& s){char* tmp = (char*)malloc(strlen(this->m_data) + strlen(s.m_data) + 1);strcpy(tmp, this->m_data);free(this->m_data);this->m_data = (char*)malloc(strlen(tmp) + strlen(s.m_data) + 1);strcat(tmp, s.m_data);strcpy(this->m_data, tmp);free(tmp);return *this;}char operator[](int pos) const{assert(pos >= 0 && pos < Length());return *(this->m_data + pos);//return this->m_data[pos];}~String(){if (this->m_data != nullptr){free(this->m_data);this->m_data = nullptr;}}
private:char* m_data;
};ostream& operator<<(ostream& cout, const String& s)
{cout << s.m_data << endl;return cout;
}void test01()
{//String s(nullptr);//空指针不能拿来给字符串初始化或者赋值String s1("a,b,c");String s2 = s1;
}void test02()
{String s1("abc");String s2("xyz");
}void test03()
{const char* pstr = "ABCXYZ";cout << *(pstr + 1) << endl;cout << pstr[1] << endl;String s("ABC");cout << s[2] << endl;
}void test04()
{String s1("abc");String s2("xyz");s1 += s2;cout << s1;String s3;s3 = s1 + s2;cout << s3;
}int main()
{test04();system("pause");return 0;
}

2.    虽然构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造 函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内 可以多次赋值。

#include<iostream>
using namespace std;class Date
{
public:Date(int year, int month, int day){this->m_year = year;this->m_month = month;this->m_day = day;}private:int m_year;int m_month;int m_day;
};

3.初始化列表

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量

const成员变量

自定义类型成员(该类没有默认构造函数)

3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

#include<iostream>
using namespace std;class Time
{
public:Time(int h=0 ) :hour(h) {}//有了全缺省有参构造可以不用默认构造public:int hour;
};class Date
{
public:Date(int day){//有了全缺省有参构造可以不用默认构造对于t，也可以不用在函数体内或者初始化列表初始化this->day = day;}public:Time t;int day;
};int main()
{Date d(10);cout << d.t.hour << endl;system("pause");return 0;
}

#include<iostream>
using namespace std;class Test1
{public:Test1(int a){t = a;}private:int t;
};class Test2
{
public:Test2(int a,int b, const Test1& t):ref(a),ca(b),t1(t){}private:int& ref;const int ca;Test1 t1;
};

成员变量初始化顺序只与成员变量定义的顺序有关。

#include<iostream>
using namespace std;class Date
{
public:Date(int year, int month, int day) :m_month(month), m_year(year), m_day(day), ref(day),c_value(100){}
private://初始化顺序只和这里的定义顺序有关，和上面的初始化列表无关int m_year;int m_month;int m_day;int& ref;//引用数据成员 必须通过参数列表进行初始化const int c_value;
};int main()
{Date dt(2023, 2, 5);system("pause");return 0;
}

初始化顺序例题：

#include<iostream>
using namespace std;class Test
{
public:Test(int a) :_a1(a), _a2(_a1){}void Print(){cout << "_a1 =" << this->_a1 << " _a2 =" << this->_a2 << endl;}private:int _a2;//先初始化a2在初始化a1int _a1;
};int main()
{Test t(1);t.Print();system("pause");return 0;
}

        隐式类型转换的发生，不一定类只有一个成员变量，可以有多个（只要缺省值够多，只剩一个或者没有未缺省的值）就可以发生隐式类型转换。

       4 友元函数：友元函数可以在类外通过对象访问类的私有成员和保护成员（这个对象可以通过传参得到，也可以通过函数内部实例化得到）。友元函数可以直接访问类的私有成员和保护成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声 明，声明时需要加friend关键字。因此友元函数没有this指针。

       注意：友元函数可访问类的私有和保护成员，但不是类的成员函数 ；

                友元函数不能用const修饰

                友元函数可以在类定义的任何地方声明，不受类访问限定符限制

                一个函数可以是多个类的友元函数

                友元函数的调用与普通函数的调用和原理相同

输出运算符重载是友元函数的典型用法， 它为了实现cout在符号左边，成员符号右边必须写成友元函数实现。

#include<iostream>
using namespace std;class A
{
friend void func(A& a);
public:A(int a = 0) :m_a(a) {}private:int m_a;
};void func(A& a)
{a.m_a = 30;cout << a.m_a << endl;A a1(50);a1.m_a = 60;cout << a1.m_a << endl;
}int main()
{A a;func(a);system("pause");return 0;
}

一个函数可以做多个类的友元函数

#include<iostream>
using namespace std;class B;class A
{
friend void func(A& a, B& b);
public:A(int a = 0):m_a(a) {}private:int m_a;
};class B
{
friend void func(A& a, B& b);
public:B(int b=0):m_b(b){ }
private:int m_b;
};void func(A& a, B& b)
{b.m_b = 20;a.m_a = 10;cout << a.m_a << " " << b.m_b << endl;
}int main()
{A a;B b;func(a, b);system("pause");return 0;
}

成员函数做友元：让一个类的成员函数作为另一个类的友元函数。友元函数可以传参或者实例化目标类的对象，这个对象可以访问目标类的非公有成员。成员函数做友元会遇到类声明顺序的问题，一般是前面的类成员访问后面类的私有成员，这样就把前面的类作用域和成员函数声明过了，能够正常声明为友元函数并进行访问，反之不行，后访问前会出现后面的类未定义，不能正常声明成友元函数。

#include<iostream>
using namespace std;class B;class A
{friend void B::PrintA(A& a);
public:void PrintB(B& b);A(int a);
private:int m_a;
};class B
{
friend void A:: PrintB(B& b);
public:B(int b);void PrintA(A& a);
private:int m_b;
};A::A(int a = 0) : m_a(a) {}
B::B(int b = 0) : m_b(b) {}void B::PrintA(A& a) 
{ a.m_a = 10;
cout << a.m_a << endl;
}void A::PrintB(B& b)
{b.m_b = 20;cout << b.m_b << endl;
}

 正确代码：

#include<iostream>
using namespace std;class B;class A
{
//friend void B::PrintA(A& a);
public:void PrintB(B& b);A(int a);
private:int m_a;
};class B
{
friend void A:: PrintB(B& b);
public:B(int b);//void PrintA(A& a);
private:int m_b;
};A::A(int a = 0) : m_a(a) {}
B::B(int b = 0) : m_b(b) {}//void B::PrintA(A& a) 
//{ a.m_a = 10;
//cout << a.m_a << endl;
//}void A::PrintB(B& b)
{b.m_b = 20;cout << b.m_b << endl;
}int main()
{A a;B b;a.PrintB(b);system("pause");return 0;
}

友元类：将一个类声明为另一个类的友元，友元类中所有的成员函数都是目标类的友元函数，可以在类外访问它的私有和保护成员。这里注意涉及到类的声明顺序，通过学习博客发现：

• 类的声明相关资料：

      不完全类型（只声明的类）只能在非常有限的情况下使用：可以定义指向这种类型的指针或引用，也可以作为一个已经声明（但没有定义）的函数的参数或返回类型。
      对于一个类来说，在创建它的对象前必须首先完成类的定义，而不能仅仅被声明。否则编译器就无法了解这样的对象需要多少存储空间。类似的，类也必须首先被定义，然后才能用引用或者指针访问其成员。

  简而言之：

      如果在一段代码中使用了A类实例化对象（为堆区开辟对象）或者成员变量、成员函数，那么A类必须在这段代码之前定义；
      如果这段代码只使用A类来定义指针或者函数参数中的数据类型那么A类可以在这段代码上面声明，而在下面定义。
  ————————————————
  版权声明：本文为CSDN博主「拒绝省略号」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
  原文链接：https://blog.csdn.net/qq_49030008/article/details/123243230

• #include<iostream>
  #include<vld.h>
  using namespace std;class B;
  class A
  {
  public:A(int a, int b);void setB(int i);void getB();~A();private:int m_a;B* pb;
  };class B
  {
  friend class A;
  public:B(int b);private:A* pa;int m_b;
  };A::A(int a=0, int b=0):m_a(a), pb(new B(b)) {}
  A::~A() { delete pb; pb = nullptr; }
  B::B(int b = 0) :m_b(b) {}void A::setB(int i)
  {this->pb->m_b = i;
  }void A::getB()
  {cout << this->pb->m_b << endl;
  }int main()
  {A a;a.setB(30);a.getB();system("pause");
  return 0;
  }

  #include<iostream>
  using namespace std;//class B;
  class A
  {
  friend class B;
  public:A(int a = 0){this->m_a = a;}/*void showB(const B& b){cout << b.m_b << endl;}*/private:int m_a;
  };class B
  {
  //friend class A;
  public:B(int b=0):m_b(b){}void showA(A& a){cout << a.m_a << endl;}private:int m_b;
  };int main()
  {A a(10);B b;b.showA(a);system("pause");return 0;
  }

1.友元关系不能被继承。

2.友元关系是单向的。

3.友元关系不具有传递性。

#include<iostream>
using namespace std;//class B;
class A
{
friend class B;
public:A(int a = 0){this->m_a = a;}/*void showB(const B& b){cout << b.m_b << endl;}*/private:int m_a;
};class B
{
//friend class A;
public:B(int b=0):m_b(b){}void showA(A& a){cout << a.m_a << endl;}private:int m_b;
};int main()
{A a(10);B b;b.showA(a);system("pause");return 0;
}

静态成员:

静态成员函数：1.静态成员函数没有this指针，静态成员函数只能访问静态成员变量。静态成员函数也受到访问权限限定符的限制。

静态成员变量：1.在编译时分配内存。

                         2.必须在类外进行初始化。

                         3.由所有对象共享，它是属于整个类的。

                         4.可以使用对象名调用也可以使用类名调用。

                         5.静态成员也受到访问权限的限制。

#include<iostream>
using namespace std;//普通可调常和静态 静态和常不能调普通
//Test* const this  普通方法this指针
// const Test* const this 常方法this指针
//静态成员函数 没有this指针class Test
{
public:Test()//:m_value(0)//不能在类内初始化{this->m_data = 0;//this->m_value = 0;//不能在类内初始化}static void Show(){//cout << "m_data =" << m_data << endl;//静态成员函数只能调动静态成员cout << "m_value" << m_value << endl;//Fun();静态成员不能调普通成员}void Fun()//普通成员可以调动静态成员{this->m_data = 1;this->m_value = 10;this->Print();//普通方法可以调动常方法this->Show();//普通方法可以调静态方法}void Print() const{cout << "This is Print()" << endl;//Fun();//常方法不能调普通方法}static int m_value;
private:int m_data;
};
//静态成员并不属于某个对象，属于整个类，所有对象共享
int Test::m_value = 0;//静态成员变量只能在类外进行初始化void test01()
{Test t1;Test t2;cout << t2.m_value << endl;t1.m_value = 100;cout << t2.m_value << endl;
}void test02()
{Test t1;t1.Fun();t1.Show();//类名和对象名都可以调用Test::Show();
}void main()
{test02();
}

静态成员可以作类的实例化对象计数器：

#include<iostream>
using namespace std;void fun2();class Test
{friend void fun(const Test& t);//没有this指针
public:Test(int data =0){this->m_data = data;this->count++;}static void ShowCount(){cout << count << endl;}~Test(){this->count--;}private:int m_data;static int count;
};
int Test::count;void test()
{Test t[100];Test::ShowCount();t[99].ShowCount();Test::ShowCount();
}void main()
{test();system("pause");
}

c11规定，可以在声明类的成员变量时，给它赋默认值，即缺省参数。

#include<iostream>
using namespace std;//友元函数可以在类外访问类的保护和私有成员
//友元函数不能用const修饰class B
{friend class A;//友元类的使用
public:B(int b = 0) :m_b(b) {}private:int m_b;
};class A 
{
public:void Print(){cout << "sizeof(p)=" << sizeof(p) << endl;cout << "b.m_b=" << this->b.m_b<< endl;cout << "a.m_a=" << this->m_a << endl;}private:int* p = (int*)malloc(sizeof(int));B b = 20;int m_a = 10;
};int main()
{A a;a.Print();system("pause");return 0;
}

内部类，一个类的内部又定义了另一个类，主要注意在内部类实例化对象时，前面要加上外部类的作用域限定符。

#include<iostream>
using namespace std;class Test
{
public:class Stu{public:void func(){cout << "AAA" << endl;}};void func(){cout << "BBB" << endl;}
};int main()
{Test t;t.func();Test::Stu s;s.func();system("pause");return 0;
}