c++知识点累积

输入输出

输入

cin >>

跳过空白字符（空格、换行符、制表符）。

#include <iostream>
#include <string>

int main()
{
	using std::cout;
	using std::cin;
	using std::endl;
	using std::string;

	string tmp("");
	cout << "input:";
	cin >> tmp;
	cout << "output:" << tmp <<endl;

	return 0;
}

输出结果：

cin.get()

该函数的声明有5种，如下。

int_type get();
_Myt& get(_Elem *_Str, streamsize _Count);
_Myt& get(_Elem *_Str, streamsize _Count, _Elem _Delim);
_Myt& get(_Elem& _Ch);
_Myt& get(_Mysb& _Strbuf);
_Myt& get(_Mysb& _Strbuf, _Elem _Delim);

输入流中取字符或者字符串。不跳过空白字符。如果是字符串，那么最多只能输入_Count-1个字符，然后最后补上一个字符串的结束符。_Delim是结束符。get函数停止接收字符的条件有2个，遇到文件结尾EOF或者结束符，或者已经取到_Count-1个字符。哪个条件新到达，取字符结束。

cin.getline()

友元

类的机制实现了数据的隐藏与封装。类的数据成员一般定义为私有成员，成员函数一般定义为公有成员。提供类与外界间的通信接口。但有时需要定义一些函数，这些函数不是类的一部分，但又需频繁访问类的数据成员，这时可以将这些函数定义为该函数的友元函数。除了友元函数外，还有友元类，两者统称为友元。友元的作用是提高了程序的运行效率（即减少了类型检查和安全性检查等都需要时间开销），但它也破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员。

友元函数

友元函数：可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以声明，声明时只需在友元的名称前加上关键字friend，其格式如下：

friend 函数返回类型函数名(形式参数);

注意：1.友元函数的声明可以放在类的私有部分，也可以放在公有部分，没有区别的，都说明是该类的一个友元函数
2. 一个函数可以是多个类的友元函数，只需要在各个类中分别声明
3. 友元函数的调用与一般函数的调用方式和原理一致

友元类

友元类：友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。定义友元类的语句格式如下：

friend class 类名; //friend和class是关键字，类名必须是程序中的一个已定义过的类。

例：

class B;
class A
{
    …
    public:
        friend class B;
    …
};

class C : public A{}; // C直接继承A，但是无法实例化，友元关系不能传递
class B : public A{}; // B直接继承A，可以实例化
class D : public B{}; // D直接继承B，可以实列化，相当于D间接继承A

类B的所有成员函数都是类A的友元函数，能存取类A的私有成员和保护成员。使用友元类时注意：1.友元关系不能被继承
2. 元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明
3. 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明

友元类特点：（上例）将导致A无法被除B以外的其它任何类直接继承以后实例化。可事实是，下面这段代码可以正常编译与运行。

#include <iostream>
using namespace std;
class A
{
public:
	A(){_a = 100; _b = 200;}
	A(int x, int y) : _a(x), _b(y) {}

	void print_pub_a()
	{
		cout << "mem1 =" << _a;
		cout << "mem2_=" << _b;
		cout << endl;
	}
private:
	int _a, _b;
	void print_priv_a()
	{
		cout << "mem1 =" << _a;
		cout << "mem2_=" << _b;
		cout << endl;
	}

	friend class B;
};

class B : public A
{
public:
	B() : _c(9988) {}

	void print_pub_b()
	{
		cout << "class B print function." << endl;
		a1.print_priv_a();
	}

private:
	int _c;
	A a1;
};

class C : public A
{
public:
	void print_pub_c()
	{
		cout << "public print function in CLASS C." << endl;
	}
};

int main(void)
{
	C c1;
	c1.print_pub_a();
}

把上面的代码稍作改动（把Class A的构造函数全部放入private域），如下，编译失败。

#include <iostream>
using namespace std;
class A
{
public:
	void print_pub_a()
	{
		cout << "mem1 =" << _a;
		cout << "mem2_=" << _b;
		cout << endl;
	}
private:
	A(){_a = 100; _b = 200;}
	A(int x, int y) : _a(x), _b(y) {}

	int _a, _b;
	void print_priv_a()
	{
		cout << "mem1 =" << _a;
		cout << "mem2_=" << _b;
		cout << endl;
	}

	friend class B;
};

class B : public A
{
public:
	B() : _c(9988) {}

	void print_pub_b()
	{
		cout << "class B print function." << endl;
		a1.print_priv_a();
	}

private:
	int _c;
	A a1;
};

class C : public A
{
public:
	void print_pub_c()
	{
		cout << "public print function in CLASS C." << endl;
	}
};

int main(void)
{
	C c1;
	c1.print_pub_a();
}

再对上面的代码稍作改动（main函数中代码全部注释掉），编译成功。

#include <iostream>
using namespace std;
class A
{
public:
	void print_pub_a()
	{
		cout << "mem1 =" << _a;
		cout << "mem2_=" << _b;
		cout << endl;
	}
private:
	A(){_a = 100; _b = 200;}
	A(int x, int y) : _a(x), _b(y) {}

	int _a, _b;
	void print_priv_a()
	{
		cout << "mem1 =" << _a;
		cout << "mem2_=" << _b;
		cout << endl;
	}

	friend class B;
};

class B : public A
{
public:
	B() : _c(9988) {}

	void print_pub_b()
	{
		cout << "class B print function." << endl;
		a1.print_priv_a();
	}

private:
	int _c;
	A a1;
};

class C : public A
{
public:
	void print_pub_c()
	{
		cout << "public print function in CLASS C." << endl;
	}
};

int main(void)
{
	//C c1;
	//c1.print_pub_a();
}

从上面的例子可以知道，class C的实例化必须要调用Class的构造函数，如果构造函数在private域，那么自然不能实例化，但是可以继承。

class C是直接从A继承，如果让class c从B继承又会怎么样呢？看下面的代码，C从B处间接继承A，因为B是A的友元函数，所以即使A的构造函数在private域，那么C也是可以调用到，因此可实例化。

#include <iostream>
using namespace std;
class A
{
public:
	void print_pub_a()
	{
		cout << "mem1 =" << _a;
		cout << "mem2_=" << _b;
		cout << endl;
	}
private:
	A(){_a = 100; _b = 200;}
	A(int x, int y) : _a(x), _b(y) {}

	int _a, _b;
	void print_priv_a()
	{
		cout << "mem1 =" << _a;
		cout << "mem2_=" << _b;
		cout << endl;
	}

	friend class B;
};

class B : public A
{
public:
	B() : _c(9988) {}

	void print_pub_b()
	{
		cout << "class B print function." << endl;
		a1.print_priv_a();
	}

private:
	int _c;
	A a1;
};

class C : public B
{
public:
	void print_pub_c()
	{
		cout << "public print function in CLASS C." << endl;
	}
};

int main(void)
{
	C c1;
	c1.print_pub_a();
}

在上面的代码中，如果不让C通过B的友元间接继承A，那么可以像下面这样实现。A的构造函数放在private域，B是A的友元类，同时B从A共有继承（使用virtual）。那么没有其他的类可以直接或者间接的从A处继承。下面编译会失败。

#include <iostream>
using namespace std;
class A
{
public:
	void print_pub_a()
	{
		cout << "mem1 =" << _a;
		cout << "mem2_=" << _b;
		cout << endl;
	}
private:
	A(){_a = 100; _b = 200;}
	A(int x, int y) : _a(x), _b(y) {}

	int _a, _b;
	void print_priv_a()
	{
		cout << "mem1 =" << _a;
		cout << "mem2_=" << _b;
		cout << endl;
	}

	friend class B;
};

class B : virtual public A
{
public:
	B() : _c(9988) {}

	void print_pub_b()
	{
		cout << "class B print function." << endl;
		a1.print_priv_a();
	}

private:
	int _c;
	A a1;
};

class C : public B
{
public:
	void print_pub_c()
	{
		cout << "public print function in CLASS C." << endl;
	}
};

int main(void)
{
	C c1;
	c1.print_pub_a();
}

在上面的代码中，实例化c1时，C直接调用A的构造函数，而不是间接调用B的构造，所以会实例化失败。

1. 将A的构造函数放入private区域。2. 声明子类B为A的友元。3. 定义A为virtual public继承B。

C++关键字

final 指定符 (C++11 起)

在C++11中关键字final，用来指定派生类不能覆写虚函数，或类不能被继承。应用到成员函数时，标识符final 在类定义中的成员函数声明或成员函数定义的语法中，立即出现于声明器后。应用到类时，标识符 final 出现在类定义的起始，立即在类名后。例如下面leveldb代码中，类PosixLogger不能被其他的类继承了

namespace leveldb {

class PosixLogger final : public Logger {
 public:
  // Creates a logger that writes to the given file.
  //
  // The PosixLogger instance takes ownership of the file handle.
  explicit PosixLogger(std::FILE* fp) : fp_(fp) {
    assert(fp != nullptr);
  }

  ~PosixLogger() override {
    std::fclose(fp_);
  }
  
.......
.......
.......

 private:
  std::FILE* const fp_;
};

}  // namespace leveldb

#endif  // STORAGE_LEVELDB_UTIL_POSIX_LOGGER_H_

override 指定符(C++11 起)

在C++11中关键字override，它用来指定基类中的虚成员函数需要在子类中显式地重写，如果没有重写则编译器报错。例如在上面代码中就有关键字override的使用

default 指定符

在C++11中关键字default，它用来显式默认化的函数定义，令编译器为类生成特殊成员函数或比较运算符 (C++20 起)的显式指令。其中特殊成员函数有：默认构造函数、复制构造函数、移动构造函数 (C++11 起)、复制赋值运算符、移动赋值运算符 (C++11 起)、析构函数。即，如果某个特殊成员函数在声明时使用了default，那么编译器会为该函数自动生成函数体。例如leveldb代码

namespace leveldb 
{

  class LEVELDB_EXPORT Cache;

  // Create a new cache with a fixed size capacity.  This implementation
  // of Cache uses a least-recently-used eviction policy.
  LEVELDB_EXPORT Cache* NewLRUCache(size_t capacity);

  class LEVELDB_EXPORT Cache {
  public:
    Cache() = default;

    Cache(const Cache&) = delete;
    Cache& operator=(const Cache&) = delete;

    // Destroys all existing entries by calling the "deleter"
    // function that was passed to the constructor.
    virtual ~Cache();

    // Opaque handle to an entry stored in the cache.
    struct Handle { };

  ......
  ......

}//class Cache

}//namespace leveldb

关于cache的定义时，使用了该关键字。

delete 指定符

在C++11中关键字delete，它的定义与default是一样的，但是功能不一样。delete指示禁止使用特殊成员函数。在上面的代码中使用到了关键字delete

static

在类中声明static变量或者函数时，初始化时使用作用域运算符来标明它所属类，因此，静态数据成员是类的成员，而不是对象的成员，这样就出现以下作用：
(1)类的静态成员函数是属于整个类而非类的对象，所以它没有this指针，这就导致它仅能访问类的静态数据和静态成员函数。
(2)不能将静态成员函数定义为虚函数。
(3)由于静态成员声明于类中，操作于其外，所以对其取地址操作，就多少有些特殊，变量地址是指向其数据类型的指针，函数地址类型是一个“nonmember函数指针”。
(4)由于静态成员函数没有this指针，所以就差不多等同于nonmember函数，结果就产生了一个意想不到的好处：成为一个callback函数，使得我们得以将C++和C-based X W indow系统结合，同时也成功的应用于线程函数身上。（这条没遇见过）
(5)static并没有增加程序的时空开销，相反她还缩短了子类对父类静态成员的访问时间，节省了子类的内存空间。
(6)静态数据成员在<定义或说明>时前面加关键字static。
(7)静态数据成员是静态存储的，所以必须对它进行初始化。（程序员手动初始化，否则编译时一般不会报错，但是在Link时会报错误）
(8)静态成员初始化与一般数据成员初始化不同:
初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆；
初始化时不加该成员的访问权限控制符private，public等；
初始化时使用作用域运算符来标明它所属类；
所以我们得出静态数据成员初始化的格式：<数据类型><类名>::<静态数据成员名>=<值>
(9)为了防止父类的影响，可以在子类定义一个与父类相同的静态变量，以屏蔽父类的影响。这里有一点需要注意：我们说静态成员为父类和子类共享，但我们有重复定义了静态成员，这会不会引起错误呢？不会，编译器采用了一种绝妙的手法：name-mangling 用以生成唯一的标志。

#include <iostream>
using namespace std;

class UnitTest
{
public:
	UnitTest* GetInstance(void)
	{
		static UnitTest instance;
		return &instance;
	}
};
int main(void)
{
	UnitTest u;

	cout << u.GetInstance() << endl;
	cout << u.GetInstance() << endl;
}

上面，在函数GetInstance(void)中，不论调用多少次，instance只定义一次（第一次被调用时），后面每一次调用时得到相同的instance。

const

const修饰成员函数，不能修改任何的成员变量(mutable修饰的变量除外)
const成员函数不能调用非const成员函数，因为非const成员函数可以会修改成员变量

//google test source code
const TestInfo* current_test_info() const GTEST_LOCK_EXCLUDED_(mutex_);

explicit

explicit可以抑制内置类型隐式转换，所以在类的构造函数中，最好尽可能多用explicit关键字，防止不必要的隐式转换.

c++知识点累积

输入输出

输入

友元

C++关键字

linux安装cuda和cudnn

模拟手机设备：使用 Playwright 实现移动端自动化测试

Mellanox网卡开启SR-IOV

全面系统的AI学习路径，帮助普通人也能玩转AI

HTML 00 Tutorial

uni-app实现上拉加载

vue3编译优化之“静态提升”

又是一个月-20240513

flask 如何保证返回json有序

linux服务器设置ssh免密

Print Calendar

c++知識點累積

getchar() 與 getch()

《讓makefile變得簡單》系列--第二章--讓我們來寫一個makefile

《讓makefile變得簡單》系列--第一章

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結