Setw 

是C++中用于设置输出字段宽度的函数。当使用 setw(3) 时，它会设置紧接着的输出字段的最小宽度为3个字符。如果字段内容长度小于3，则会在左侧填充空格以达到指定宽度；如果内容长度大于或等于3，则全部内容将被输出，不进行填充。

#include <iostream>
#include <iomanip>
using namespace std;

int main() {
// 设置宽度为3，输出"1"，左侧填充两个空格
cout << setw(3) << "1" << endl;
// 输出"1234"，不进行填充，因为长度已经超过3
cout << "1234" << setw(3) << "1234" << endl;
return 0;
}

代码题

C++输入一个自然数，将该数反序输出

#include <stdio.h>
int main()
{
   int n,m;
   printf(“输入一个自然数:”);
   scanf("%d",&n);
   while(n>0)
   {
     m=n%10;
     printf("%d ",m);
     n=n/10;
   }
}

读一行文件数字

#include <iostream>
#include<sstream>
#include<fstream>
using namespace std ;
void main(){
   ifstream in(" input.txt ");
   for(string s;getline(in, s);{
       int a, sum =0;
       for(istringstream sin(s);sin>>a;sum+=a);
       cout<<sum<<endl;
      }
}

具体来说，getline(in, s) 执行以下操作：

• 它尝试从由 in 所引用的输入流中读取字符，并存储这些字符到字符串 s 中，直到遇到换行符（\n）为止。
• 读取结束后，换行符不会被存储到 s 中，而是被丢弃。
• 如果在到达文件末尾之前没有遇到换行符，那么输入流将被设置为失效状态，表示已到达文件末尾或者发生了错误。
• 每次调用 getline() 后，它会自动移除已经读取的那一行末尾的换行符，并将其后的内容留待下次读取。

for(string s; getline(in, s);) 这个循环会持续从 "input.txt" 文件中读取每一行文本到字符串 s 中，直到文件结束为止。对于每一行，程序都会计算该行中所有整数的和并输出结果。

• istringstream sin(s); 创建了一个名为 sin 的 istringstream 对象，并用字符串 s 初始化它。这意味着 sin 现在可以像输入流一样对待字符串 s，允许您从中逐个提取值。
• 之后的循环 for(istringstream sin(s); sin >> a;) 利用了 >> 操作符从 sin 流中逐个提取整数并存储到变量 a 中。每次提取后，流的位置会自动向前移动，因此可以在下一次迭代时提取下一个数值。
• 在循环体内部，执行 sum += a; 来累加这些从字符串中提取出来的整数值。

 strncpy和strcpy的区别

strcpy 和 strncpy 都是 C 语言标准库中的字符串复制函数，它们都定义在 <string.h> 头文件中。尽管这两个函数的功能相似，但它们之间有一些重要的区别：

strcpy

• 功能：strcpy 函数用于将源字符串（包括终止空字符 \0）复制到目标数组中。它不会检查目标数组的大小，这意味着如果源字符串长度超过了目标数组的容量，可能会导致缓冲区溢出。
• 原型：

  char *strcpy(char *dest, const char *src);

• 注意事项：使用 strcpy 时需要特别小心，确保目标数组足够大以容纳源字符串的所有字符以及终止空字符。

strncpy

• 功能：strncpy 函数也用于复制字符串，但它接受一个额外的参数 n，表示最多复制 n 个字符。如果源字符串的长度小于 n，则会在目标字符串后面填充足够的空字符 \0 使其总长达到 n。如果源字符串的长度大于或等于 n，那么目标字符串将不会被自动以 \0 结尾。
• 原型：

  char *strncpy(char *dest, const char *src, size_t n);

• 注意事项：由于 strncpy 不保证目标字符串以 \0 结尾，当源字符串长度大于或等于 n 时，您需要手动确保目标字符串以 \0 结尾，否则可能导致未定义行为。

主要区别总结

1. 安全性：strcpy 不提供对目标数组越界的保护，容易导致安全问题；而 strncpy 提供了一定程度的安全性，通过限制最大复制字符数来避免溢出，但仍需注意手动添加终止符。
2. 终止符：strcpy 保证目标字符串总是以 \0 结尾；而 strncpy 只有在复制的字符数少于 n 时才会添加 \0，否则需要用户自己确保目标字符串以 \0 结束。
3. 性能：strncpy 在某些情况下可能比 strcpy 慢，因为它需要额外的操作来填充剩余的空间为 \0（当源字符串长度小于 n 时）。

选择使用哪一个函数应根据具体的需求和上下文环境来决定，考虑到安全性、性能以及是否需要手动处理字符串的终止符。在现代编程实践中，推荐使用更安全的替代方案，如使用 snprintf 或者 C++ 中的 std::string 类，以避免潜在的缓冲区溢出问题。

多重继承

#include<iostream>
using namespace std;

class Base 
{
public:
    int Bvalue;
    Base(int v) : Bvalue(v) {}
};

// 使用虚继承
class D1 : virtual public Base
{
public:
    int Dvalue;
    D1(int v, int b) : Base(v), Dvalue(b) {}
};

// 使用虚继承
class D2 : virtual public Base
{
public:
    int D2value;
    D2(int v, int c) : Base(v), D2value(c) {}
};

// 修改构造函数以初始化虚基类
class D : public D1, public D2
{
public:
    int Dvalue;
    D(int a, int b, int c, int d) : Base(a), D1(a, b), D2(c, d), Dvalue(d) {}
};

int main()
{
    D obj(1, 2, 3, 4);
    cout << obj.Bvalue << endl; // 现在可以正确访问 Bvalue
    return 0;
}
在这个修改版本中，D1 和 D2 都使用了虚继承(virtual public Base)来继承 Base 类。这保证了 Base 类只被实例化一次，从而解决了名称冲突和二义性问题。同时，在 D 类的构造函数中，需要直接调用 Base 的构造函数来初始化唯一的 Base 实例。这样，obj.Bvalue 就能正确访问 Base 类中的 Bvalue 成员了。

代码模式
D1(int v, int b) : Base(v)这是什么意思？
D1(int v, int b) : Base(v) 这部分代码是 C++ 中的成员初始化列表（Member Initializer List）语法，用于在构造函数体内执行任何计算之前初始化基类或成员变量。让我们详细拆解一下这个表达式的含义：

构造函数声明
D1(int v, int b)：这是 D1 类的构造函数声明，它接受两个参数 v 和 b。
成员初始化列表
: Base(v)：这是成员初始化列表的一部分，用于在进入构造函数体之前初始化基类 Base 或者对象的数据成员。在这个例子中，: Base(v) 表示使用传入的参数 v 来初始化基类 Base 的构造函数。
具体来说，当创建一个 D1 类的对象时，D1 的构造函数首先会通过调用基类 Base 的构造函数来初始化继承自 Base 的那部分数据成员（即 Bvalue）。这里假设 Base 类有一个接受单个整数参数的构造函数 Base(int v)，它将这个值赋给 Base 类中的成员变量 Bvalue。

完整解释
所以，完整的 D1 类构造函数 D1(int v, int b) : Base(v) 的含义是：

接受两个参数 v 和 b。
使用 v 参数调用基类 Base 的构造函数，以初始化从 Base 继承来的成员变量（如 Bvalue）。
然后，在构造函数体 { Dvalue = b; } 内，使用 b 参数初始化 D1 自己的成员变量 Dvalue。
示例代码片段
cpp
深色版本
class Base 
{
public:
    int Bvalue;
    Base(int v) : Bvalue(v) {} // 基类构造函数
};

class D1 : public Base
{
public:
    int Dvalue;
    D1(int v, int b) : Base(v) // 调用基类构造函数初始化Bvalue
    {
        Dvalue = b; // 初始化D1自己的成员变量Dvalue
    }
};

在多重继承情况下，基类成员的名称冲突导致的。具体来说，在您的代码中，D 类从 D1 和 D2 继承，而这两个类又都从 Base 类继承。这意味着 D 类中有两个 Base 类的实例（即两个 Bvalue 成员），这会导致名称冲突。

在 C++ 中，当一个派生类通过多个路径继承同一个基类时，默认情况下该基类会在每个路径下被单独实例化，除非使用虚继承来避免重复实例化。因此，当你尝试访问 obj.Bvalue 时，编译器无法确定你指的是哪个 Bvalue，因为存在两个 Base 实例。

为了解决这个问题，可以使用虚继承（virtual inheritance），这样可以确保无论通过多少个路径继承，基类都只会被实例化一次。
D1 和 D2 都使用了虚继承(virtual public Base)来继承 Base 类。这保证了 Base 类只被实例化一次，从而解决了名称冲突和二义性问题。同时，在 D 类的构造函数中，需要直接调用 Base 的构造函数来初始化唯一的 Base 实例。这样，obj.Bvalue 就能正确访问 Base 类中的 Bvalue 成员了。

枚举

enum Color{ blue=1, yellow, green, white=8, black, red } favorite;

favorite 是一个类型为 Color 的变量。定义枚举类型的同时声明了一个该类型的变量是C++的一种语法特性，这意味着 favorite 是直接与 Color 枚举类型关联的一个实例。

具体来说，favorite 可以存储 Color 枚举中的任何一个值（即 blue, yellow, green, white, black, red），这些值分别对应整数值 1, 2, 3, 8, 9, 10。因此，您可以将 favorite 设置为这些枚举常量中的任意一个来表示不同的颜色选择。

例如：

• 如果你执行 favorite = blue;，那么 favorite 的值将是 1。
• 如果你执行 favorite = red;，那么 favorite 的值将是 10。

此外，由于 favorite 是一个 Color 类型的变量，你可以对它进行与枚举相关的操作，如赋值、比较等

字符指向导致内存泄漏

p->name = new char[10]; 
p->name = "Liumei";

这里发生了两步关键操作：

1. 分配内存：new char[10] 为 p->name 分配了一个大小为10的字符数组，并让 p->name 指向这块新分配的内存。
2. 重新赋值：紧接着，p->name = "Liumei"; 将 p->name 直接指向了字符串字面值 "Liumei"。这意味着 p->name 不再指向之前通过 new 分配的那块内存。

内存泄漏的原因

• 在第一步中，您分配了一块内存用于存储字符数据，并且这块内存的地址被保存在 p->name 中。
• 然而，在第二步中，您将 p->name 直接设置为指向一个常量字符串 "Liumei" 的地址。这导致 p->name 不再指向最初分配的那块内存区域。因此，最初分配的那块内存（即通过 new char[10] 分配的）失去了所有引用，无法再通过程序中的任何指针访问到它。这种情况下，这块内存就成为了“孤立”的，程序无法再释放它，从而造成了内存泄漏。

解决方案

为了避免这种情况，应该使用 strcpy 或类似的函数来复制字符串内容到已分配的内存空间中，而不是直接改变指针的指向。例如：

p->name = new char[10];
strcpy(p->name, "Liumei");

这样做之后，p->name 仍然指向通过 new char[10] 分配的内存，但该内存的内容已经被替换为 "Liumei" 字符串的内容。这样既不会丢失对分配内存的引用，也正确地初始化了 p->name 所指向的数据。当不再需要这块内存时，可以通过 delete[] p->name; 来安全地释放它，避免内存泄漏。

构造函数初始化

派生类构造函数的成员初始化列表中，不能包含(C)

A.基类的构造函数

B.派生类中成员对象的初始化

C.基类中成员对象的初始化

D.派生类中一般数据成员的初始化

class Base {

 Member obj;

public:

 Base(int x) : obj(x) {}

};

假设基类有一个成员对象，

然后派生类Derived继承自Base，如果Derived的构造函数想要初始化Base中的obj成员，是否可以直接在Derived的初始化列表中这样做？例如：

Derived::Derived(...) : Base(...), obj(...) { ... }

这样是否正确？显然是不正确的，因为obj是属于Base类的成员，只能在Base类的构造函数初始化列表中进行初始化。而派生类只能控制如何调用基类的构造函数，而不能直接初始化基类的成员对象。因此，选项C确实是不可行的，所以正确答案应该是选项C。

构造与析构（顺序）

#include <iostream>
using namespace std ;
class Myclass {
	int data;
public:
	Myclass()
	{
		cout << " constructor is called, " << endl; data - 0;
	}
	~Myclass()
	{
		cout << " destructor is called, " << endl;
	}
};
int main()
{
  Myclass obj[3];
  return 0;
}

由于 obj 是一个包含 3 个元素的数组，因此：

• 在声明 Myclass obj[3]; 时，构造函数会被调用 3 次（分别为数组中的每个元素创建一个对象），所以你会看到 "constructor is called," 输出 3 次。
• 当程序执行到 main 函数的结尾，obj 数组中的对象开始被销毁，析构函数也将被调用 3 次，"destructor is called," 将输出 3 次。

• 在C++中，当对象是一个数组的一部分时，析构函数的调用顺序与构造函数的调用顺序相反。具体来说：

• 构造函数按照对象在数组中的顺序从前往后依次调用（即，对于Myclass obj[3];，首先是obj[0]，然后是obj[1]，最后是obj[2]）。
• 析构函数则按照对象构造的相反顺序调用，也就是从数组的最后一个元素开始，向前逐一析构（即，先析构obj[2]，然后是obj[1]，最后是obj[0]）。

拷贝构造的传参问题

Myclass(Myclass x)
{
    data = x.data;
    cout << "copy constructor is called" << endl;
}

1. 参数传递方式：在这个拷贝构造函数中，参数 Myclass x 是通过值传递的。这意味着在调用拷贝构造函数时，实际上需要先创建一个临时对象来作为参数 x 传入，而创建这个临时对象本身又会调用拷贝构造函数，从而导致无限递归。

正确的：

Myclass(const Myclass& x)
{
    data = x.data;
    cout << "copy constructor is called" << endl;
}

 多态性

#include <iostream>
using namespace std; 
class CShape {
public:
	virtual float area()
	{
		return 0.0;
	}
};
class CTriangle : public CShape {
public:
	CTriangle(float h = 0, float w = 0) { H = h; W = w; }float area() { return 0.5 * H * W; }
private:
	float H, W;
};
class CCircle : public CShape {
public:
	CCircle(float r = 0) { R = r; }float area() { return 3.14 * R * R; }
private:
	float R;
};
		
int main() 
{
	CShape shape;
	cout << " shape.area()= " << shape.area() << endl;
	CTriangle tri(3, 4);
	cout << " tri.area()= " << tri.area() << endl;
	CCircle cir(5);
	cout << " cir.area()= " << cir.area() << endl;
	CShape* s1 = &tri;
	cout << " s1->area()= " << s1->area() << endl;
	CShape& s2 = cir;
	cout << " s2.area()= " << s2.area() << endl;
	return 0;
}

在C++中，当一个基类指针或引用指向或引用一个派生类对象，并且通过该指针或引用来调用一个虚函数时，会根据实际对象的类型来决定调用哪个版本的函数。这种机制被称为动态绑定或多态性。详细解释一下s1->area()和s2.area()的例子：

s1->area()

• 定义：CShape* s1 = &tri;
• 这里，s1是一个指向基类CShape类型的指针，但它实际上指向的是派生类CTriangle的对象tri。
• 当通过s1->area();调用area()函数时，由于area()在基类CShape中被声明为virtual（虚函数），程序会在运行时根据s1实际指向的对象类型（这里是CTriangle）来决定调用哪个版本的area()函数。
• 因此，尽管s1是CShape类型的指针，它调用的是CTriangle类中的area()函数实现，输出为 s1->area()= 6。

s2.area()

• 定义：CShape& s2 = cir;
• 在这里，s2是基于基类CShape类型的引用，但实际引用的是派生类CCircle的对象cir。
• 类似地，当你调用s2.area();时，因为area()是虚函数，程序会根据s2所引用的实际对象类型（这里是CCircle）来确定调用哪个area()函数的版本。
• 尽管s2是作为CShape类型被引用的，但由于多态性的存在，真正执行的是CCircle类中的area()函数，因此输出为 s2.area()= 78.5。

 拷贝构造问题：

#include <iostream>
#include <cstring> // 使用<cstring>而非string.h
using namespace std;

class Student {
    char* name;
    int age; 
    float score;
public:
    Student(const char* n, int a, float s) : age(a), score(s) { // 改为const char*
        cout << " constructing..." << n << endl; 
        name = new char[strlen(n) + 1];
        strcpy(name, n);
    }
    Student(const Student& s) { // 正确实现深拷贝
        cout << " copy constructing... " << s.name << endl; 
        name = new char[strlen(s.name) + 1];
        strcpy(name, s.name);
        age = s.age;
        score = s.score; 
        // 移除误导的析构输出
    }

    ~Student() {
        cout << "destructing..." << name << endl;
        delete[] name; // 正确释放内存
    }
};

int main() {
    Student s1("Liu", 18, 86.5), s2 = s1; // 正确调用构造函数和拷贝构造函数
    return 0;
}

当类中没有自定义拷贝构造函数时，C++编译器会生成默认的拷贝构造函数，这个默认拷贝构造函数会按成员进行浅拷贝（即逐字节复制内存）。

对于你的 Student 类：

• name 成员是一个动态分配的 char* 指针。

• 默认拷贝构造函数会将 s2.name 直接指向 s1.name 的地址（即两者指向同一块内存）。

• 在析构的时候会造成对同一个地址进行二次析构，造成程序崩溃

链表的构造和异构

#include <iostream>
using namespace std ;

struct Node {
	int data;
	Node* next;
};

class LinkList {
	Node* head;
public:
	LinkList(int data[], int n)
	{
		head = new Node;
		head->data = 0;
		head->next = nullptr;
		Node* tail = head; //尾指针
		for (int i = 0; i < n; i++)
		{
			Node* ret = new Node;
			ret->data = data[i];
			ret->next = nullptr;
			tail->next = ret;
			tail = ret;
			
		}
	}
	LinkList(void)
	{
		cout << "constructing an empty linked list." << endl;
		head = new Node;
		head->next = nullptr;
	}

	void Print(void)
	{
		if (head->next == nullptr)
		{
			cout << "empty" << endl;
			return;
		}
		Node* t = head->next;
		while (t != nullptr)
		{
			cout << t->data << ",";
			t = t->next;
		}
	}
	~LinkList()
	{
		if (head== nullptr)
		{
			delete head;
		}
		Node* t = head;
		while (t != nullptr)
		{
			Node* ret = t;
			t = t->next;
			delete ret;
		}
		head == nullptr;
	}
};

int main()
{
	int a[] = { 1,2,3,4,5 };
	int size = sizeof(a) / sizeof(a[0]);
	LinkList mylist(a, size);
	mylist.Print();
	cout << endl;
	
	LinkList mylist2;//制造空链表，不能用加（），mylist2（）；当然，可以选择不加，也可以选择加上{} ：mylist2{}
	mylist2.Print();
	cout << endl;
	return 0;
}