1. Toy模板网首页
  2. > Toy博客

【深入浅出C#】章节 5: 高级面向对象编程：泛型编程和集合类型

9月前 作者：喵叔哟 分类：Toy博客 阅读(61) 违法举报

这篇具有很好参考价值的文章主要介绍了【深入浅出C#】章节 5: 高级面向对象编程：泛型编程和集合类型。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

高级面向对象编程是在基础面向对象编程的基础上进一步深入和拓展的一种编程范式。它强调封装、继承和多态的概念，并引入了泛型编程和集合类型等高级特性。高级面向对象编程提供了更灵活、可扩展和可复用的代码结构，能够帮助开发者构建更复杂、更高效的应用程序。高级面向对象编程中，泛型编程使得代码可以更加通用和灵活，能够处理不同类型的数据而无需重复编写相似的代码。集合类型则提供了丰富的数据结构和算法，使得数据的管理和操作更加便捷和高效。
通过深入理解和应用高级面向对象编程的概念和特性，开发者可以设计出更可靠、可维护和可扩展的软件系统。这种编程范式在现代软件开发中扮演着重要的角色，为开发者提供了强大的工具和思维方式，能够更好地满足不断变化的需求和挑战。

一、泛型编程的概念和作用

1.1 泛型的定义和特点

泛型是一种在编程语言中引入的特性，它允许在定义类、接口、方法等时使用类型参数，从而实现代码的通用性和灵活性。通过泛型，可以编写出能够适用于多种类型的代码，而无需重复编写相似的代码逻辑。
泛型的主要特点包括：

  1. 类型参数化：泛型允许在定义时使用类型参数，这样可以将具体的类型信息延迟到使用时确定，从而使代码更具通用性。
  2. 类型安全性：泛型在编译时进行类型检查，可以在编译阶段捕获类型错误，避免在运行时出现类型不匹配的错误。
  3. 代码复用性：通过泛型，可以编写出适用于不同类型的通用代码，避免了重复编写相似的代码逻辑。
  4. 性能优化：泛型在编译时生成针对具体类型的特化代码，从而提高了执行效率，避免了装箱和拆箱等开销。
  5. 扩展性：泛型允许在使用时指定具体的类型参数，从而使代码可以适应不同的数据类型，具有很高的扩展性。
1.2 泛型的优势和应用场景

泛型在编程中具有许多优势和应用场景，包括：

  1. 代码复用和通用性：泛型允许编写通用的代码，可以适用于多种数据类型，避免了重复编写相似的代码逻辑，提高了代码的复用性。
  2. 类型安全和可靠性：泛型在编译时进行类型检查，可以在编译阶段捕获类型错误，减少了运行时类型相关的错误，提高了代码的可靠性。
  3. 性能优化：泛型在编译时生成针对具体类型的特化代码，避免了装箱和拆箱等开销，提高了代码的执行效率。
  4. 数据结构和算法的实现：泛型广泛应用于数据结构和算法的实现中，可以轻松地创建适用于不同类型的数据结构和算法，提高了代码的可扩展性和灵活性。
  5. 集合类和容器类：泛型使得集合类和容器类能够存储和操作不同类型的数据，提供了更加灵活和通用的数据管理工具。
  6. 接口和委托的使用：泛型可以与接口和委托结合使用，使得代码更加灵活和可扩展，提供了更强大的编程模式。

泛型的应用场景非常广泛，特别是在需要处理多种数据类型的场景下，如数据结构、算法实现、集合类和容器类、数据库操作等。通过合理地应用泛型，可以提高代码的复用性、可维护性和性能，同时降低了开发的复杂度。

1.3 泛型类型和方法的声明和使用

泛型类型和方法的声明和使用可以通过以下方式实现：

  1. 泛型类型的声明和使用：
// 声明泛型类
class MyGenericClass<T>
{
    private T myField;

    public MyGenericClass(T value)
    {
        myField = value;
    }

    public T MyMethod()
    {
        return myField;
    }
}

// 使用泛型类
MyGenericClass<int> intObj = new MyGenericClass<int>(10);
int value = intObj.MyMethod();  // 返回整数类型

MyGenericClass<string> stringObj = new MyGenericClass<string>("Hello");
string text = stringObj.MyMethod();  // 返回字符串类型
  1. 泛型方法的声明和使用：
// 声明泛型方法
class MyGenericClass
{
    public T MyMethod<T>(T value)
    {
        return value;
    }
}

// 使用泛型方法
MyGenericClass myObj = new MyGenericClass();
int intValue = myObj.MyMethod(10);  // 返回整数类型

string stringValue = myObj.MyMethod("Hello");  // 返回字符串类型

二、集合类型的概念和分类

2.1 集合类型的定义和作用

集合类型是用于存储和操作一组相关数据的数据结构。它们提供了方便的方法来添加、删除、访问和搜索集合中的元素。在C#中，常见的集合类型包括数组、列表、字典、集合和队列等。
集合类型的作用包括：

  1. 存储和组织数据：集合类型提供了一种有效的方式来存储和组织大量数据，使其易于访问和管理。
  2. 提供高效的数据操作：集合类型提供了各种方法和操作符来执行常见的数据操作，如查找、插入、删除和排序等，以便更方便地处理数据。
  3. 支持动态大小：与数组不同，集合类型可以根据需要动态调整大小，以适应不同数量的元素。
  4. 提供类型安全性：集合类型可以指定存储特定类型的元素，从而提供类型安全性，避免错误的数据类型被添加到集合中。
  5. 实现特定的数据结构：不同类型的集合可以实现不同的数据结构，如列表、字典、堆栈和队列等，以满足不同的数据操作需求。

通过选择适当的集合类型，可以更有效地组织和处理数据，提高代码的可读性和维护性。它们在各种应用程序中都有广泛的应用，包括数据处理、算法实现、用户界面和网络编程等领域。

2.2 常见的集合类型

  1. 数组(Array):

    • 定义语法：T[] arrayName; (其中T为元素类型)
    • 创建数组：T[] arrayName = new T[length];
    • 访问元素：arrayName[index]
    • 示例：
      int[] numbers = new int[5];
numbers[0] = 1;
numbers[1] = 2;
// ...

  2. 列表(List):

    • 定义语法：List<T> listName = new List<T>(); (其中T为元素类型)
    • 添加元素：listName.Add(element);
    • 访问元素：listName[index]
    • 示例：
      List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");
// ...

  3. 字典(Dictionary):

    • 定义语法：Dictionary<TKey, TValue> dictionaryName = new Dictionary<TKey, TValue>(); (其中TKey为键类型，TValue为值类型)
    • 添加键值对：dictionaryName.Add(key, value);
    • 访问值：dictionaryName[key]
    • 示例：
      Dictionary<int, string> ages = new Dictionary<int, string>();
ages.Add(1, "Alice");
ages.Add(2, "Bob");
// ...

  4. 集合(Set):

    • 定义语法：HashSet<T> setName = new HashSet<T>(); (其中T为元素类型)
    • 添加元素：setName.Add(element);
    • 检查元素是否存在：setName.Contains(element)
    • 示例：
      HashSet<string> uniqueNames = new HashSet<string>();
uniqueNames.Add("Alice");
uniqueNames.Add("Bob");
// ...

  5. 队列(Queue):

    • 定义语法：Queue<T> queueName = new Queue<T>(); (其中T为元素类型)
    • 入队：queueName.Enqueue(element);
    • 出队：queueName.Dequeue()
    • 示例：
      Queue<int> numbers = new Queue<int>();
numbers.Enqueue(1);
numbers.Enqueue(2);
// ...
2.3 集合类型的特点和使用场景

集合类型具有以下特点和使用场景：

  1. 数组(Array):

    • 特点：具有固定长度，可通过索引直接访问元素。
    • 使用场景：适用于已知长度且需要快速随机访问元素的情况。

  2. 列表(List):

    • 特点：可动态调整大小，提供了丰富的操作方法（添加、删除、查找等）。
    • 使用场景：适用于需要频繁插入、删除和遍历元素的情况。

  3. 字典(Dictionary):

    • 特点：使用键值对存储数据，快速通过键进行查找。
    • 使用场景：适用于需要根据键快速查找和访问对应值的情况。

  4. 集合(Set):

    • 特点：存储唯一的元素，提供了高效的去重功能。
    • 使用场景：适用于需要存储唯一元素的情况，如查找重复项或创建无序集合。

  5. 队列(Queue):

    • 特点：先进先出(FIFO)的数据结构，支持在队尾添加元素，在队头移除元素。
    • 使用场景：适用于需要按照先后顺序处理元素的情况，如任务调度、消息处理等。

每种集合类型都有其独特的特点和适用场景，根据实际需求选择合适的集合类型可以提高程序的效率和可读性。

三、集合类型的使用

3.1 集合类型的常用操作和方法

以下是数组、列表、字典、集合和队列的常用操作和方法，以及相应的案例示例：

  1. 数组（Array）：

    • 访问元素：使用索引访问数组元素。
    • 获取长度：使用Length属性获取数组长度。
    • 遍历数组：使用for循环或foreach循环遍历数组。

    示例：

    int[] numbers = { 1, 2, 3, 4, 5 };
int firstElement = numbers[0];
int length = numbers.Length;
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

  2. 列表（List）：

    • 添加元素：使用Add方法向列表添加元素。
    • 移除元素：使用Remove方法移除列表中的元素。
    • 查找元素：使用Contains方法判断列表是否包含某个元素。

    示例：

    List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");
names.Remove("Alice");
bool containsBob = names.Contains("Bob");

  3. 字典（Dictionary）：

    • 添加键值对：使用Add方法添加键值对。
    • 移除键值对：使用Remove方法移除指定键的键值对。
    • 获取键值对数量：使用Count属性获取键值对数量。

    示例：

    Dictionary<string, int> ages = new Dictionary<string, int>();
ages.Add("Alice", 25);
ages.Add("Bob", 30);
ages.Remove("Alice");
int count = ages.Count;

  4. 集合（Set）：

    • 添加元素：使用Add方法向集合添加元素。
    • 移除元素：使用Remove方法移除集合中的元素。
    • 查找元素：使用Contains方法判断集合是否包含某个元素。

    示例：

    HashSet<string> names = new HashSet<string>();
names.Add("Alice");
names.Add("Bob");
names.Remove("Alice");
bool containsBob = names.Contains("Bob");

  5. 队列（Queue）：

    • 入队：使用Enqueue方法将元素加入队列。
    • 出队：使用Dequeue方法从队列中移除并返回队首元素。

    示例：

    Queue<int> queue = new Queue<int>();
queue.Enqueue(1);
queue.Enqueue(2);
int firstElement = queue.Dequeue();
3.2 集合类型的遍历和元素访问

以下是数组、列表、字典、集合和队列的遍历和元素访问方法：

  1. 数组（Array）：

    • 遍历：使用for循环或foreach循环遍历数组元素。
    • 元素访问：使用索引访问数组元素。

    示例：

    int[] numbers = { 1, 2, 3, 4, 5 };
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

  2. 列表（List）：

    • 遍历：使用foreach循环遍历列表元素。
    • 元素访问：使用索引访问列表元素。

    示例：

    List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");
foreach (string name in names)
{
    Console.WriteLine(name);
}

string firstElement = names[0];

  3. 字典（Dictionary）：

    • 遍历键值对：使用foreach循环遍历字典中的键值对。
    • 元素访问：使用键访问字典中的值。

    示例：

    Dictionary<string, int> ages = new Dictionary<string, int>();
ages.Add("Alice", 25);
ages.Add("Bob", 30);
foreach (KeyValuePair<string, int> pair in ages)
{
    Console.WriteLine(pair.Key + ": " + pair.Value);
}

int aliceAge = ages["Alice"];

  4. 集合（Set）：

    • 遍历：使用foreach循环遍历集合元素。
    • 元素访问：集合没有索引，可以使用foreach循环遍历集合元素并访问。

    示例：

    HashSet<string> names = new HashSet<string>();
names.Add("Alice");
names.Add("Bob");
foreach (string name in names)
{
    Console.WriteLine(name);
}

  5. 队列（Queue）：

    • 遍历：队列没有直接的遍历方法，可以通过将队列元素转移到其他数据结构中进行遍历。
    • 元素访问：使用Peek方法获取队首元素。

    示例：

    Queue<int> queue = new Queue<int>();
queue.Enqueue(1);
queue.Enqueue(2);

// 将队列元素转移到列表中进行遍历
List<int> queueList = new List<int>(queue);
foreach (int number in queueList)
{
    Console.WriteLine(number);
}

int firstElement = queue.Peek();

四、集合类型的迭代和LINQ查询

4.1 迭代集合类型的方式和循环遍历

在C#中，可以使用不同的方式迭代和遍历集合类型，包括数组、列表、字典、集合和队列。以下是一些常用的迭代和遍历方式：

  1. 使用foreach循环：

    • 适用于数组、列表、集合等实现了IEnumerable接口的类型。
    • 遍历每个元素，无需关注索引或键。
    • 示例：
      int[] numbers = { 1, 2, 3, 4, 5 };
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

List<string> names = new List<string>() { "Alice", "Bob", "Charlie" };
foreach (string name in names)
{
    Console.WriteLine(name);
}

  2. 使用for循环：

    • 适用于数组或具有索引的集合类型。
    • 需要关注元素的索引。
    • 示例：
      int[] numbers = { 1, 2, 3, 4, 5 };
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

List<string> names = new List<string>() { "Alice", "Bob", "Charlie" };
for (int i = 0; i < names.Count; i++)
{
    Console.WriteLine(names[i]);
}

  3. 使用迭代器（IEnumerator或IEnumerator<T>）：

    • 适用于需要手动控制迭代过程的情况。
    • 需要使用MoveNext()方法移动到下一个元素，并使用Current属性获取当前元素。
    • 示例：
      List<string> names = new List<string>() { "Alice", "Bob", "Charlie" };
IEnumerator<string> enumerator = names.GetEnumerator();
while (enumerator.MoveNext())
{
    string name = enumerator.Current;
    Console.WriteLine(name);
}

无论使用哪种方式，都可以对集合类型进行迭代和遍历，访问每个元素并执行相应的操作。具体选择哪种方式取决于集合类型和具体需求。

4.2 LINQ查询的概念和基本用法

LINQ（Language Integrated Query）是一种在C#中用于查询和操作数据的语言集成查询技术。它提供了一种统一的语法和方式来查询不同类型的数据源，如集合、数据库、XML等。

基本用法如下：

  1. 引入命名空间：在文件顶部引入System.Linq命名空间。
  2. 创建数据源：可以是一个集合、数组、数据库表等。
  3. 构建查询表达式：使用LINQ查询表达式构建查询。表达式类似于SQL语句，用于指定查询条件、排序方式等。
  4. 执行查询：使用LINQ提供的方法，如ToList()、ToArray()、First()等，执行查询并返回结果。

示例代码：

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        // 创建数据源
        int[] numbers = { 1, 2, 3, 4, 5 };

        // 构建查询表达式
        var evenNumbers = from number in numbers
                          where number % 2 == 0
                          select number;

        // 执行查询
        foreach (var number in evenNumbers)
        {
            Console.WriteLine(number);
        }
    }
}

上述示例中，通过LINQ查询表达式筛选出数组numbers中的偶数，并使用foreach循环输出结果。

LINQ还支持其他强大的功能，如分组、排序、投影等。通过LINQ，可以使用统一的语法来处理不同类型的数据源，简化了查询和操作数据的过程，提高了代码的可读性和可维护性。

五、集合类型的排序和比较

5.1 集合类型的排序方法和算法

集合类型在C#中提供了多种排序方法和算法，可以根据具体的需求选择合适的方式进行排序。

  1. 使用 Sort() 方法：集合类型（如列表）提供了 Sort() 方法，可以直接对集合进行原地排序。默认情况下，Sort() 方法使用元素的自然顺序进行排序。如果需要自定义排序规则，可以使用委托或 Lambda 表达式指定比较器。

    示例代码：

    List<int> numbers = new List<int> { 5, 3, 1, 4, 2 };
numbers.Sort(); // 默认按升序排序

  2. 使用 LINQ 的 OrderBy() 方法：通过 LINQ 查询表达式中的 orderby 子句，可以对集合进行排序。可以使用 ascending 或 descending 关键字指定排序顺序，并使用属性或表达式作为排序键。

    示例代码：

    List<int> numbers = new List<int> { 5, 3, 1, 4, 2 };
var sortedNumbers = numbers.OrderBy(x => x); // 按升序排序

  3. 使用 Comparer 类进行自定义排序：Comparer 类提供了多种静态方法，可用于创建自定义的比较器。可以实现 IComparer<T> 接口或使用 Comparison<T> 委托来定义自定义比较器，并将其传递给排序方法。

    示例代码：

    List<int> numbers = new List<int> { 5, 3, 1, 4, 2 };
numbers.Sort((x, y) => y.CompareTo(x)); // 自定义降序排序

  4. 使用 LINQ 的 OrderBy() 方法和自定义比较器：可以结合 LINQ 的 OrderBy() 方法和自定义比较器来实现复杂的排序需求。自定义比较器需要实现 IComparer<T> 接口，并在 OrderBy() 方法中指定比较器。

    示例代码：

    List<int> numbers = new List<int> { 5, 3, 1, 4, 2 };
var sortedNumbers = numbers.OrderBy(x => x, new CustomComparer()); // 使用自定义比较器进行排序
5.2 自定义比较器和排序规则

在 C# 中，可以通过自定义比较器来定义排序规则。比较器是实现了 IComparer<T> 接口的类或使用 Comparison<T> 委托的方法，用于比较两个对象的大小关系。

以下是自定义比较器和排序规则的示例代码：

// 定义自定义比较器实现 IComparer<T> 接口
public class CustomComparer : IComparer<int>
{
    public int Compare(int x, int y)
    {
        // 自定义排序规则：按绝对值大小进行排序
        int absX = Math.Abs(x);
        int absY = Math.Abs(y);
        return absX.CompareTo(absY);
    }
}

// 使用自定义比较器进行排序
List<int> numbers = new List<int> { -5, 3, -1, 4, -2 };
numbers.Sort(new CustomComparer());

// 输出排序结果
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

在上述示例中，定义了一个名为 CustomComparer 的自定义比较器，实现了 IComparer<int> 接口，并在 Compare 方法中定义了自定义的排序规则，即按绝对值大小进行排序。然后，使用 Sort 方法并传入自定义比较器的实例，对列表中的元素进行排序。

通过自定义比较器，可以灵活地定义排序规则，以满足具体的排序需求。可以根据对象的属性、字段或其他自定义逻辑来确定对象的大小关系，从而实现按特定规则排序的功能。

六、集合类型的性能和最佳实践

集合类型的性能和最佳实践是开发过程中需要考虑的重要因素。以下是一些关于集合类型性能和最佳实践的建议：

  1. 选择合适的集合类型：根据具体的需求选择适合的集合类型。例如，如果需要快速随机访问元素，可以选择使用数组或列表；如果需要高效地进行搜索和插入操作，可以选择使用字典或集合等。
  2. 避免频繁的集合复制：对大型集合进行频繁的复制操作会消耗大量的内存和时间。尽量避免不必要的集合复制，特别是在循环中。
  3. 使用正确的数据结构：根据具体的数据操作需求选择合适的数据结构。例如，如果需要按键进行快速查找，使用字典会比列表更高效；如果需要维护排序顺序，可以使用排序集合等。
  4. 考虑集合的大小：对于大型数据集，考虑使用延迟加载或分页加载的方式来减少内存消耗和提高性能。
  5. 使用迭代器而不是复制集合：使用迭代器遍历集合可以避免不必要的集合复制，提高性能和内存效率。
  6. 注意集合的线程安全性：在多线程环境下使用集合时，确保采取适当的线程安全措施，例如使用锁或并发集合。
  7. 避免频繁的插入和删除操作：某些集合类型在频繁插入和删除操作时性能较低，考虑使用其他更适合的集合类型或优化算法。
  8. 注意内存管理：在不需要使用集合时及时释放集合，避免造成内存泄漏。

七、总结

在高级面向对象编程中，泛型编程和集合类型是重要的概念和工具。泛型提供了一种通用的方式来创建可重用和类型安全的代码，使代码更加灵活和可扩展。泛型类型和方法可以根据需要使用不同的数据类型，提高代码的灵活性和性能。
集合类型是存储和管理数据的容器，包括数组、列表、字典、集合和队列等。它们提供了不同的功能和特点，可以根据需求选择合适的集合类型。集合类型的使用涉及到元素的添加、删除、访问、排序等操作，需要熟悉相应的方法和算法。
在使用集合类型时，我们需要考虑性能和最佳实践。选择合适的集合类型、避免不必要的集合复制、使用正确的数据结构、考虑集合的大小、使用迭代器、注意线程安全性、避免频繁的插入和删除操作等都是优化集合性能的重要因素。同时，合理的内存管理和遵循编码规范也能提高代码的质量和可维护性。
通过理解和应用泛型编程和集合类型，我们可以更好地组织和管理数据，提高代码的可复用性和可扩展性，加快开发效率，并且有效地解决复杂的问题。文章来源地址https://www.toymoban.com/news/detail-595236.html

到了这里，关于【深入浅出C#】章节 5: 高级面向对象编程：泛型编程和集合类型的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【深入浅出C#】章节 1：C#入门介绍：C#开发环境的设置和配置

    【深入浅出C#】章节 1：C#入门介绍：C#开发环境的设置和配置

    一、环境准备 1.1 安装和配置.NET Core 当配置C#开发环境时，安装.NET Core是一个重要的步骤。以下是安装.NET Core的基本过程： 访问官方网站：打开浏览器，访问.NET Core的官方网站：https://dotnet.microsoft.com/en-us/download。 选择下载版本：在官方网站上，选择所需的.NET Core版本。通常

    2024年02月13日
    浏览(50)

  • 【深入浅出C#】章节10: 最佳实践和性能优化：内存管理和资源释放

    一、 内存管理基础 1.1 垃圾回收机制 垃圾回收概述 垃圾回收（Garbage Collection）是一种计算机科学和编程领域的重要概念，它主要用于自动管理计算机程序中的内存分配和释放。垃圾回收的目标是识别和回收不再被程序使用的内存，以便释放资源并防止内存泄漏，从而提高程

    2024年02月09日
    浏览(54)
  • 【C++深入浅出】类和对象下篇

    【C++深入浅出】类和对象下篇

            老样子，先来回顾一下上期的内容：上期我们着重学了C++类中的六大 默认成员函数 ，并自己动手实现了一个 日期类 ，相信各位对C++中的类已经有了一定程度的了解。本期就是类和对象的最后一篇啦，终于要结束咯，吧唧吧唧         话不多说，开吃咯！！！ 2.1

    2024年02月08日
    浏览(61)
  • 理解C#委托（Delegate）通俗易懂，深入浅出

    理解C#委托（Delegate）通俗易懂，深入浅出

    委托首先是一个数据类型，我们可以像定义结构体一样定义一个委托类型，委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变 委托的定义 例如： 在定义委托类型时要指定函数的参数类型和返回值，一旦声明了委托类型，委托对象必须使用

    2024年02月02日
    浏览(52)
  • 深入浅出Java的多线程编程——第二篇

    深入浅出Java的多线程编程——第二篇

    目录 前情回顾 1. 中断一个线程 1.1 中断的API 1.2 小结 2. 等待一个线程  2.1 等待的API 3. 线程的状态 3.1 贯彻线程的所有状态 3.2 线程状态和状态转移的意义 4. 多线程带来的的风险-线程安全 (重点) 4.1 观察线程不安全 4.2 线程安全的概念 4.3 线程不安全的原因 4.3.1 修改共享数据

    2024年02月07日
    浏览(81)
  • 【C++深入浅出】C/C++内存管理（教你如何new到对象）

    【C++深入浅出】C/C++内存管理（教你如何new到对象）

            前面我们学习了有关C++类和对象的知识，学会了如何构建一个完整的类，这些类都是存储在 栈空间 上的。在C语言中，我们不仅可以在栈上定义变量，也可以对 堆 上的空间进行管理，在接下来的几期中，我们的目标就是 学会C++中是如何进行内存管理的 。        

    2024年02月08日
    浏览(49)
  • 【C++深入浅出】类和对象中篇（六种默认成员函数、运算符重载）

    【C++深入浅出】类和对象中篇（六种默认成员函数、运算符重载）

    目录 一. 前言  二. 默认成员函数 三. 构造函数 3.1 概念 3.2 特性 四. 析构函数 4.1 概念 4.2 特性 五. 拷贝构造函数 5.1 概念 5.2 特性 六. 运算符重载 6.1 引入 6.2 概念 6.3 注意事项 6.4 重载示例 6.5 赋值运算符重载 6.6 前置++和后置++运算符重载 七. const成员函数 7.1 问题引入 7.2 定义

    2024年02月09日
    浏览(63)
  • 【C++深入浅出】类和对象上篇(类的基础、类的模型以及this指针)

    【C++深入浅出】类和对象上篇(类的基础、类的模型以及this指针)

    目录 一. 前言  二. 面向对象与面向过程         2.1 面向过程         2.2 面向对象 三. 类的基础知识 3.1 类的引入 3.2 类的定义 3.3 成员变量的命名规则 3.4 封装 3.5 类的访问限定符 3.6 类的作用域 3.7 类的实例化 四. 类的对象模型 4.1 类对象的大小 4.2 类对象的存储方式 4.3 空

    2024年02月10日
    浏览(55)

  • 深入浅出 C 语言：学变量、掌控流程、玩指针，全方位掌握 C 编程技能

    C 语言介绍 C 语言的特性 C 语言相对于其他语言的优势 C 程序的编译 C 中的 Hello World 程序 参考文章： C 语言入门：如何编写 Hello World C 语言函数：入门指南 C 中的变量和 C 语言中的作用域规则 C 中的数据类型 运算符及其类型 C 语言中的类型转换 参考文章： C 语言注释

    2024年02月02日
    浏览(45)

  • 【深入浅出Selenium库的百变玩法】: 掌握Web自动化测试的关键技术和策略，包括元素定位、页面操作、动态内容处理等，适用于初学者和高级开发者的综合指南

    Selenium是一个功能强大的库，支持多种高级操作，如处理多窗口、多标签页、键盘与鼠标事件、滚动操作等。掌握Selenium可以大大提高Web应用的测试效率和覆盖范围。希望这篇文章能帮助你开启Selenium进行自动化测试的新篇章。 Selenium也是一个广泛使用的自动化测试工具，它支

    2024年02月20日
    浏览(63)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包