cpp | Academic

C++中的const

Thu, 02 Mar 2023 12:34:40 +0000

在C++中，const是一个关键字，用于指定一个变量或对象的值将不会被修改。 const可以用于不同的变量类型，例如整数，浮点数，字符，指针等。在这个文档中，我们将探讨const的一些用途。

常量

使用const定义常量是C++中的一种最常见的用途。在定义变量时，将变量定义为const将确保在程序的其余部分中不会更改变量的值。这对于程序的可维护性和易读性非常重要。

以下是一个使用const定义常量的示例：

const int MAX_VALUE = 100;

在上面的示例中，我们定义了一个名为MAX_VALUE的常量，并将其值设置为100。在程序的其余部分中，当我们使用MAX_VALUE时，我们知道它的值将始终为100。

函数参数

在函数定义中，const可以用于指定参数是只读的。这可以确保在函数内部不会更改参数的值。这对于编写安全和可靠的代码非常重要。

以下是一个使用const在函数参数中指定只读的示例：

int sum(const int x, const int y)
{
return x + y;
}

在上面的示例中，我们定义了一个名为sum的函数，它接受两个const整数参数，这意味着函数内部不会更改这些参数的值。

成员函数

在C++中，const也可以用于类的成员函数。 const成员函数保证不会修改类的数据成员，因此它们可以安全地由const对象调用。

以下是一个使用const在类的成员函数中指定只读的示例：

class MyClass
{
public:
int getValue() const
{
return value;
}
private:
int value = 10;
};
int main()
{
const MyClass obj;
std::cout << obj.getValue() << std::endl;
return 0;
}

在上面的示例中，我们定义了一个名为MyClass的类，它具有一个const成员函数getValue()，该函数返回类的值成员。在main()函数中，我们创建了一个const对象obj，并调用了getValue()函数，因为该函数是const成员函数，因此可以安全地由const对象调用。

总结

在C++中，const是一种非常有用的关键字，用于定义常量，指定函数参数为只读以及定义类的const成员函数。这对于编写安全和可维护的代码非常重要。

const 和static的区别

const和static是C++中两个非常常见的关键字，它们的用途有些相似，但也有很多不同之处。 const用于指定变量值不会被修改，而static用于指定变量在整个程序生命周期内只有一个实例。

其中，const和static还有一个重要的区别：const变量可以在编译时初始化，而static变量必须在程序运行时初始化。这意味着const变量的值不能在程序运行时更改，而static变量的值可以在程序运行时更改。

另一个重要的区别是，const变量在程序的整个生命周期内都是只读的，而static变量可以在程序的任何地方进行读写操作。因此，const变量是更加安全和可靠的，而static变量则更加灵活和易于使用。

const int 和 int const 和 int * const

const int *和int const *是等效的，指针指向常量，它们都表示指向常量整数的指针，这意味着指向的内容不能更改。（const 在 * 前）

int * const表示一个指针是常量，该指针不能修改，但是可以更改指针指向的内容。(const 在 * 后)

int * const a 代表这个指针 const了不能改 int const *b 代表这个指针指的内容不能动了

注意，const关键字可以位于*的左侧或右侧，含义不同

#include <iostream>

int main() {
 std::cout << "Hello, World!" << std::endl;

 int * const a = new int(1);
 *a=1;
 //a=new int(2); error
 std::cout << *a << std::endl;

 int const * b = new int(2);
 const int * c = new int(3);
 // *b=2; error
 // *c=3; error
 b=new int(4);
 c=new int(5);

 std::cout << *b << std::endl;
 std::cout << *c << std::endl;
 return 0;
}

const int * const a表示一个指针是常量，指向的内容也是常量，指针和指向的内容都不能修改。

const int * const GetX() const

const int *和int const *是等效的，都表示指向常量整数的指针。 int * const表示指针是常量，指针指向的内容可以改变。在函数返回值类型前面的const表示函数返回值是常量，不能被修改。

在C++中，const也可以用于类的成员函数。 const成员函数保证不会修改类的数据成员，因此它们可以安全地由const对象调用。

以下是一个使用const在类的成员函数中指定只读的示例：

class MyClass
{
public:
 int getValue() const
 {
 return value;
 }

private:
 int value = 10;
};

int main()
{
 const MyClass obj;
 std::cout << obj.getValue() << std::endl;
 return 0;
}

const int *和int const *是等效的，都表示指向常量整数的指针。
int * const表示指针是常量，指针指向的内容可以改变。
const int * const表示指针是常量，指向的内容也是常量，指针和指向的内容都不能修改。

C++中的mutable

Thu, 02 Mar 2023 12:34:40 +0000

在C++中，关键字mutable用于允许一个const对象的成员变量被修改。在使用mutable关键字修饰的成员变量的时候，可以在const成员函数中修改该变量。这是因为，const成员函数默认情况下不允许修改类的数据成员。

mutable关键字通常用于缓存变量（cache variable）。一个const成员函数可以使用mutable修饰的变量作为缓存，来避免重复计算。同时，由于该变量是mutable的，因此即使在const成员函数中，也可以被修改。

下面是一个示例：

class MyClass {
 public:
 void myFunc() const {
 if(!cacheValid) {
 // perform some heavy calculations
 // and store the result in cache
 cache = 42;
 cacheValid = true;
 }
 // use cache
 }
 private:
 mutable int cache;
 mutable bool cacheValid = false;
};

在上面的示例中，cache和cacheValid被标记为mutable，因此可以在const成员函数myFunc()中被修改。如果没有mutable关键字，cache和cacheValid就不能在const成员函数中被修改。

需要注意的是，mutable变量的修改只在当前对象中生效，不会影响到其他对象。因此，mutable变量不会破坏C++的const语义。

C++中的static

Thu, 02 Mar 2023 12:34:40 +0000

在C++中，static是一种关键字，它可以应用于不同的元素，例如变量、函数和类成员等，它的含义有所不同。

静态变量

当static用于变量时，它可以将变量声明为静态变量。静态变量有以下特点：

静态变量存储在静态存储区，而不是栈上或堆上。
静态变量在程序运行时只被初始化一次，并一直存在于内存中，直到程序结束。
静态变量默认被初始化为0。

下面是一个使用静态变量的示例：

#include <iostream>

void increment() {
 static int i = 0;
 i++;
 std::cout << i << std::endl;
}

int main() {
 increment();
 increment();
 increment();
 return 0;
}

输出：

1
2
3

静态函数

当static用于函数时，它可以将函数声明为静态函数。静态函数有以下特点：

静态函数只能在声明它的文件中使用，不能被其他文件调用。
静态函数不能访问非静态变量。

下面是一个使用静态函数的示例：

#include <iostream>

static void static_function() {
 std::cout << "This is a static function." << std::endl;
}

void non_static_function() {
 std::cout << "This is a non-static function." << std::endl;
}

int main() {
 static_function();
 non_static_function();
 return 0;
}

输出：

This is a static function.
This is a non-static function.

静态类成员

当static用于类的成员变量和成员函数时，它可以将它们声明为静态成员。静态成员有以下特点：

静态成员是类的所有对象共享的，它们只有一份拷贝。
静态成员可以被类的所有对象访问和修改，也可以通过类名和作用域运算符直接访问和修改。
静态成员可以初始化为常量或表达式。

下面是一个使用静态类成员的示例：

#include <iostream>

class MyClass {
 public:
 static int static_variable;
 static void static_function();
 int non_static_variable;
 void non_static_function();
};

int MyClass::static_variable = 0;

void MyClass::static_function() {
 std::cout << "This is a static function." << std::endl;
}

void MyClass::non_static_function() {
 std::cout << "This is a non-static function." << std::endl;
}

int main() {
 MyClass obj1, obj2;
 obj1.static_variable = 1;
 obj2.static_variable = 2;
 std::cout << obj1.static_variable << std::endl;
 std::cout << obj2.static_variable << std::endl;
 obj1.static_function();
 obj1.non_static_function();
 return 0;
}

输出：

2
2
This is a static function.
This is a non-static function.

单例模式是一种常见的设计模式，它可以确保一个类只有一个实例，并提供访问该实例的全局点。

下面是使用静态方法实现单例模式的示例：

#include <iostream>

class Singleton {
 public:
 static Singleton& getInstance() {
 static Singleton instance;
 return instance;
 }
 void showMessage() {
 std::cout << "Hello, World!" << std::endl;
 }
 private:
 Singleton() {}
 Singleton(const Singleton&);
 Singleton& operator=(const Singleton&);
};

int main() {
 Singleton& instance1 = Singleton::getInstance();
 Singleton& instance2 = Singleton::getInstance();
 instance1.showMessage();
 instance2.showMessage();
 return 0;
}

输出：

Hello, World!
Hello, World!

在上面的示例中，getInstance方法是静态方法，它返回一个Singleton类的引用。在该方法中，我们使用了静态变量instance来保存Singleton类的唯一实例。由于静态变量存储在静态存储区，因此它们只会被初始化一次，并一直存在于内存中，直到程序结束。通过返回instance的引用，我们可以在程序的任何地方访问Singleton类的唯一实例。

请注意，在Singleton类的构造函数、拷贝构造函数和赋值运算符中，我们将它们声明为私有的。这是因为我们不希望用户创建Singleton类的其他实例，从而确保Singleton类只有一个实例。

C++中的可见性

Thu, 02 Mar 2023 12:34:40 +0000

C++中的可见性

在C++中，可见性是一个非常重要的概念。它指的是变量、函数、类等在不同的作用域中的可见性范围。C++中的作用域分为全局作用域和局部作用域。

在全局作用域中定义的变量、函数、类等可以在文件的任何地方被访问，也可以被其他文件所共享。而在局部作用域中定义的变量、函数、类等只能在其定义的块中被访问，无法被其他块所访问。

在C++中，还有一些特殊的作用域，例如命名空间。命名空间可以将一组相关的变量、函数、类等组织在一起，以避免命名冲突并提高代码的可读性。

访问修饰符

另外，在C++中，还可以使用访问修饰符来控制类成员的可见性。C++中有三种访问修饰符，分别是public、private和protected。public修饰符表示该成员对外可见，可以被类的外部和派生类访问；private修饰符表示该成员仅对类内可见，不可以被类的外部和派生类访问；protected修饰符表示该成员仅对类内和派生类可见，不可以被类的外部访问。

class 里不写默认 private struct 里不写默认 public

友元类

除了访问修饰符，C++还提供了友元类的概念。友元类可以访问类的私有和保护成员，但并不是类的成员。使用友元类可以在一定程度上突破类成员访问权限的限制，但也需要慎重使用，以避免破坏类的封装性和数据安全。

总之，C++中的可见性是一个非常重要的概念。了解和掌握好C++中的可见性，可以帮助我们更好地组织和管理代码，提高代码的可读性和可维护性。

C++中的字符串

Thu, 02 Mar 2023 12:34:40 +0000

在C++中，字符串是一组字符的序列。在处理字符串时，我们会用到char类型。

Char类型

Char是C++中的一种数据类型，表示单个字符。我们可以使用单引号将字符括起来，例如：

char letter = 'a';

Char类型占用1个字节的内存空间，可以存储所有ASCII字符集中的字符，包括字母、数字、符号等。在C++中，char类型的取值范围是-128到127。

在处理字符串时，我们通常会将一组字符存储在char类型的数组中。

字符数组

C++中的字符串可以通过字符数组来实现。例如：

char str[10] = "Hello World";

这里定义了一个名为str的字符数组，并初始化为"Hello World"。我们可以使用类似于访问数组元素的方式来访问字符串中的每个字符。例如，要访问字符串中的第一个字符，可以使用以下代码：

char first = str[0];

字符串库

C++中提供了一些字符串处理的函数，例如strlen、strcpy、strcat等。这些函数可以帮助我们更方便地处理字符串。

strlen：用于获取字符串的长度。
strcpy：用于将一个字符串复制到另一个字符串中。
strcat：用于将一个字符串拼接到另一个字符串的末尾。

char str1[6] = "Hello";
char str2[6] = "World";
char str3[50];
int len;
// 复制str1到str3
strcpy(str3, str1);
// 将str2拼接到str3末尾
strcat(str3, str2);
// 获取str3的长度
len = strlen(str3);

以上代码将会得到str3的值为"Hello World"，len的值为11。

char * 的隐式转换

在C++中，char * str 和 char str[] 都可以用来表示字符串，但是它们有一些区别。

char * str 实际上是一个指向字符数组的指针，它指向的是字符串的首地址。我们可以通过改变指针的位置来改变字符串的内容。例如：

char * str = "Hello";
str = "World";

这里我们将指针str从原来的"Hello"改变为了"World"。

另一方面，char str[] 是一个字符数组，它在定义时需要指定数组的长度，且该长度不能被改变。例如：

char str[10] = "Hello";

在这个例子中，定义了一个长度为10的字符数组，并将其初始化为"Hello"。如果我们想要将另一个字符串复制到该数组中，我们需要使用字符串库函数strcpy，例如：

char str[10];
strcpy(str, "World");

这里我们使用了strcpy函数将"World"复制到了str数组中。

总的来说，char * str 更加灵活，可以通过改变指针的位置来改变字符串的内容，但是需要注意指针的安全性。char str[] 在定义时需要指定数组的长度，更加安全，但是不够灵活。

举个例子：

char * str = "Hello";
cout << str << endl; // 输出 "Hello"
str = "World";
cout << str << endl; // 输出 "World"
char str2[10] = "Hello";
cout << str2 << endl; // 输出 "Hello"
strcpy(str2, "World");
cout << str2 << endl; // 输出 "World"

一般用 char * str 好操作，要不你char str[] 这种数组你在最后得给他加\0 才算是字符串呢

‘\0’

在C++中，’\0’是一个特殊的字符，表示字符串的结束。在使用字符数组表示字符串时，我们需要在数组的末尾添加’\0’来表示字符串的结束。例如：

char str[10] = "Hello";
str[5] = '\0';

这里我们将字符数组str的第6个元素赋值为’\0’，表示字符串的结束。此时，str中存储的字符串为"Hello"。

总的来说，对于字符数组表示的字符串，我们需要注意添加’\0’来表示字符串的结束，避免出现意外的错误。

#include

在C++中，除了使用char类型和字符数组来处理字符串，我们还可以使用库。这个库提供了丰富的字符串处理函数，例如length、substr、find等。使用这些函数可以更加方便地进行字符串操作。

例如，我们可以使用以下代码来创建一个字符串对象并输出其长度：

#include <string>
#include <iostream>
using namespace std;
int main() {
string str = "Hello World";
cout << str.length() << endl;
return 0;
}

以上代码将会输出字符串"Hello World"的长度，也就是11。

总的来说，C++提供了多种处理字符串的方法，我们可以根据实际情况选择合适的方法来进行字符串操作。

底层是 const char[]

总结

在C++中，我们可以使用char类型和字符数组来处理字符串。同时，也可以利用C++提供的字符串库函数进行更方便的字符串处理操作。

C++中的字符串字面量

Thu, 02 Mar 2023 12:34:40 +0000

C++中的字符串字面量是由双引号包围的字符序列。它们被视为指向字符数组的指针，其中数组的最后一个元素是空字符。以下是一个字符串字面量的示例：

const char* str = "Hello, World!";

在上面的示例中，“Hello, World!“是字符串字面量。可以在程序中使用字符串字面量来表示文本或字符序列。例如，您可以将它们用作函数参数或将它们赋值给字符数组变量。

需要注意的是，字符串字面量是常量，不允许修改其内容。如果您尝试修改字符串字面量中的任何字符，则会导致编译错误。比如你想这么搞

const char* str = "Hello, World!";
str[2]='x';

就会报错了

另外，C++11引入了原始字符串字面量，它们由R”()“语法表示，其中括号内的字符序列被视为原始字符串。这意味着在原始字符串中，转义字符不会被解释。以下是一个原始字符串字面量的示例：

const char* raw_str = R"(C:\\Users\\John\\Documents\\)";

在上面的示例中，R”()“中的字符序列被视为原始字符串，其中的反斜杠不需要进行转义。

总之，字符串字面量是C++中常用的表示文本或字符序列的方式，而原始字符串字面量则可以方便地表示包含反斜杠的路径或正则表达式等。

别的char类型

在C++中，除了字符串字面量外，还有其他类型的字符字面量。例如，单引号括起来的字符字面量表示单个字符。例如，‘a’表示字符a，‘0’表示数字0。这些字符字面量可以用作函数参数或赋值给字符变量。

此外，还有一种宽字符字面量，用L"“语法表示。它们与字符串字面量类似，但使用宽字符（wchar_t）而不是普通字符（char）。这些宽字符字面量在处理国际化和本地化问题时非常有用

字符串相加不能直接用+

因为这些事字符串字面量，实际上他们是字符数组，或者字符指针，所以我们不能把两个指针相加

解决方案1

解决方案2

s其实就是个操作函数

字符串字面量在内存中

在C++中，字符串字面量被存储在程序的只读数据区中，并在程序启动时加载到内存中。这意味着它们不能被修改，并且必须使用const char*或const char[]类型的指针来引用它们。

由于字符串字面量是常量，因此它们可以在编译时进行优化。例如，如果两个字符串字面量具有相同的值，则它们可能会共享存储空间，从而减少程序的内存占用。

需要注意的是，如果在程序中使用大量的字符串字面量，则可能会增加程序的内存占用。为了减少内存使用量，应该考虑使用动态分配内存来存储字符串，或者使用字符串流等工具来动态构建字符串。

C++中的引用

Thu, 02 Mar 2023 12:34:40 +0000

在C++中，引用是一种将变量绑定到另一个变量的方法。引用可以被视为变量的别名，它们与指针有些相似，但有一些重要的区别。

引用是在定义时初始化的，一旦初始化完成，就不能再将其绑定到另一个变量或修改它所绑定的变量。与之相反的是，指针可以被重新赋值来指向不同的变量。

另一个重要的区别是，引用不能为null，而指针可以为null。这意味着引用不需要在使用之前进行空指针检查，从而减少了代码的复杂性和错误的可能性。

引用通常用于将函数的参数传递给其他函数。通过使用引用作为参数，可以避免将大型对象进行复制，从而提高程序的性能。同样，引用也可以用于从函数中返回值，而无需创建新的对象。

在C++中，引用是非常有用的工具，可以用来编写高效且易于阅读的代码。理解引用的概念和用法对于成为C++开发人员是至关重要的一步。

引用在C++中可以理解成一种语法糖，编译器对其不进行编译，只停留在代码文本层面，仅代表了一个变量的另一个名字，可以在程序员编码时更加高效，代码保持干净

以下是引用的一个例子：

#include <iostream>
using namespace std;
void swap(int& x, int& y) {
int temp = x;
x = y;
y = temp;
}
int main() {
int a = 5;
int b = 10;
cout << "Before swap, a = " << a << " and b = " << b << endl;
// Pass variables by reference to swap function
swap(a, b);
cout << "After swap, a = " << a << " and b = " << b << endl;
return 0;
}

在这个例子中，我们定义了一个swap函数，它接受两个整数的引用作为参数，并交换它们的值。在main函数中，我们声明了两个整数变量a和b，并将它们传递给swap函数。由于我们使用了引用参数，swap函数可以直接修改变量a和b的值，而不需要创建额外的变量或进行复制。这样可以提高程序的性能，并减少内存使用量。省的return，带来内存的开销。

C++中的指针

Thu, 02 Mar 2023 12:34:40 +0000

在C++中，指针是一种非常强大的数据类型。指针是一种变量，它存储了一个内存地址，该内存地址指向另一个变量。指针可以用于访问和操作存储在内存中的数据。

指针变量可以通过在变量名前面加上星号（*）来声明。例如，下面的代码声明了一个名为 *ptr 的整数类型指针变量：

int* ptr;

在上面的代码中，星号（*）表示 ptr 是一个指向整数类型的指针变量。指针变量在声明时必须指定指针类型，因为不同类型的指针可以存储不同类型的数据。

指针变量可以使用“&”运算符获取变量的地址。例如，下面的代码获取了整数变量 num 的地址，并将其存储在指针变量 ptr 中：

int num = 10;
int* ptr = &num;

在上面的代码中，ptr 指向 num 变量的地址。

使用指针可以访问指针所指向的变量。例如，下面的代码使用指针访问 num 变量，并将其值增加了 1：

*ptr = *ptr + 1;

在上面的代码中，星号（*）表示访问指针所指向的变量，将其值加 1。

指针还可以用于动态内存分配。通过使用 new 运算符，可以在程序运行时动态地分配内存。例如，下面的代码分配了一个整数类型的内存块，并将其地址存储在指针变量 ptr 中：

int* ptr = new int;

在上面的代码中，new 运算符分配了一个整数类型的内存块，并返回其地址，该地址被存储在指针变量 ptr 中。

指针还可以用于访问数组中的元素。例如，下面的代码声明了一个指向整数类型的指针变量，然后使用该指针访问数组中的元素：

int arr[5] = {1, 2, 3, 4, 5};
int* ptr = arr; // ptr 指向数组的第一个元素
for(int i = 0; i < 5; i++) {
cout << *ptr << endl;
ptr++;
}

在上面的代码中，ptr 指向数组的第一个元素。然后，使用指针访问数组中的每个元素，并将其打印到控制台上。

指针是一种非常强大的数据类型，在 C++ 中具有广泛的应用。了解指针的工作原理和使用方法是编写高效程序的重要一步。

C++中的接口（纯虚函数）

Thu, 02 Mar 2023 12:34:40 +0000

在C++中，接口通常用纯虚函数的形式来实现。纯虚函数是一种没有实现的虚函数，其定义需要在派生类中完成。接口中只有纯虚函数，没有数据成员和函数定义，因此派生类必须实现接口中定义的所有纯虚函数，否则编译器会报错。

接口可以用于实现多态性，一个类可以继承多个接口，从而具有多个行为。例如，一个图形界面程序可以定义一个绘制图形的接口和一个处理用户输入的接口，不同的图形对象可以继承不同的接口，以实现不同的行为。

以下是一个简单的接口示例：

class Shape {
public:
 virtual void draw() = 0;
};

class Circle : public Shape {
public:
 void draw() {
 // 绘制圆形
 }
};

class Square : public Shape {
public:
 void draw() {
 // 绘制正方形
 }
};

在这个示例中，Shape类是一个接口，定义了一个纯虚函数draw()。Circle和Square类都继承了Shape类，并实现了draw()函数来绘制不同的形状。

接口的使用可以使代码更加模块化和可扩展，同时也可以提高代码的可读性和可维护性。但是，过多的接口也可能会使代码过于复杂，因此在设计时需要权衡利弊，尽量避免过多的接口设计。

其实C++没有interface 关键字

在C++中，接口的实现通常采用纯虚函数的形式。纯虚函数是没有实现的虚函数，其定义需要在派生类中完成。接口中没有数据成员和函数定义，只有纯虚函数，因此派生类必须实现接口中定义的所有纯虚函数。接口可以实现多态性，一个类可以继承多个接口，以具有不同的行为。在设计时需要权衡利弊，尽量避免过多的接口设计。

下面是一个关于接口多态的例子：

// Shape.h
class Shape {
public:
 virtual void draw() = 0;
};

// Colorful.h
class Colorful {
public:
 virtual void setColor(int r, int g, int b) = 0;
};

// Circle.h
class Circle : public Shape, public Colorful {
public:
 void draw() override {
 // 绘制圆形
 }
 void setColor override (int r, int g, int b) {
 // 设置圆形的颜色
 }
};

// Square.h
class Square : public Shape, public Colorful {
public:
 void draw() override {
 // 绘制正方形
 }
 void setColor override ****(int r, int g, int b) {
 // 设置正方形的颜色
 }
};

// main.cpp
int main() {
 Shape* shapes[2];
 shapes[0] = new Circle();
 shapes[1] = new Square();
 for (int i = 0; i < 2; i++) {
 shapes[i]->draw();
 Colorful* colorful = dynamic_cast<Colorful*>(shapes[i]);
 if (colorful != nullptr) {
 colorful->setColor(255, 0, 0);
 }
 }
 return 0;
}

在这个例子中，Shape类和Colorful类都是接口，Circle和Square类都继承了Shape类和Colorful类，并实现了draw()函数和setColor()函数来绘制不同的形状和设置不同的颜色。在main函数中，创建了一个Shape指针数组shapes，其中存放了一个Circle对象和一个Square对象。通过循环依次调用它们的draw()函数，并通过dynamic_cast将它们转换成Colorful指针，最后通过setColor()函数设置它们的颜色。

这个例子展示了接口的多态特性，通过继承不同的接口，一个类可以具有多个行为，可以在不同的情况下调用不同的函数实现不同的功能。

多态：接收一个接口作为参数

在C++中，多态可以通过接收一个接口作为参数来实现。例如，一个函数可以接收一个Shape接口作为参数，从而可以接收任意实现了Shape接口的类的对象。这样，函数就可以在不知道具体对象类型的情况下调用对象的函数。

以下是一个简单的例子：

void drawShape(Shape* shape) {
 shape->draw();
}

int main() {
 Circle circle;
 Square square;
 drawShape(&circle);
 drawShape(&square);
 return 0;
}

在这个例子中，drawShape()函数接收一个Shape接口作为参数，并调用它的draw()函数来绘制图形。在main函数中，创建了一个Circle对象和一个Square对象，并将它们的地址传递给drawShape()函数。由于Circle和Square都继承了Shape接口并实现了它的draw()函数，因此可以成功地调用它们的draw()函数来绘制图形。

多态可以使代码更加灵活和可扩展，同时也可以提高代码的可读性和可维护性。但是，过多的多态也可能会使代码过于复杂，因此在设计时需要权衡利弊，尽量避免过多的多态设计。

C++中的数组

Thu, 02 Mar 2023 12:34:40 +0000

数组是一种可以保存一系列相同类型数据的数据结构。在C++中，数组是一种容器，它可以存储一组固定大小的相同类型元素。数组中的每个元素都可以通过索引访问，索引从0开始，最大索引为数组大小减一。

在C++中，声明一个数组需要指定数组的类型、名称和大小。例如，以下代码声明了一个名为myArray的整数类型数组，大小为5：

int myArray[5];

数组元素的访问方式是通过数组名称和索引。例如，要访问数组myArray的第一个元素，可以使用以下代码：

int x = myArray[0];

在C++中，数组的大小必须是一个常量表达式，因此不能使用变量来定义数组的大小。但是，可以使用const关键字来定义一个常量，然后将其用作数组的大小。例如，以下代码定义了一个名为SIZE的常量，并将其用作数组myArray的大小：

const int SIZE = 5;
int myArray[SIZE];

在C++中，还可以使用循环来遍历数组中的所有元素。例如，以下代码使用for循环遍历数组myArray中的所有元素：

for(int i = 0; i < SIZE; i++) {
int x = myArray[i];
// 在这里使用元素值
}

总之，在C++中，数组是一种非常有用的数据结构，它可以容纳一系列相同类型的元素，并允许通过索引访问这些元素。声明一个数组需要指定数组的类型、名称和大小，然后可以使用索引访问数组中的元素。可以使用常量表达式来定义数组的大小，并可以使用循环遍历数组中的所有元素。

在堆上创建数组

在堆上创建数组需要使用new运算符。例如，以下代码创建了一个大小为5的整数类型数组：

int* myArray = new int[5];

在动态创建数组后，可以使用与静态数组相同的语法访问和操作数组元素。在完成使用数组后，必须使用delete[]运算符释放动态分配的内存。例如，以下代码释放先前创建的动态数组：

delete[] myArray;

总之，在C++中，可以使用new运算符在堆上动态创建数组。创建数组后，可以使用与静态数组相同的语法访问和操作数组元素。在完成使用数组后，必须使用delete[]运算符释放动态分配的内存。

C++11中的数组

在C++11中，引入了一个名为array的标准数组容器。array容器与静态数组类似，但具有更好的类型安全性和迭代器支持。例如，以下代码声明了一个名为myArray的整数类型array，大小为5：

#include <array>
std::array<int, 5> myArray;

可以使用at()成员函数或[]运算符来访问array容器中的元素。例如，以下代码访问myArray的第一个元素：

int x = myArray.at(0); // 或者 myArray[0];

array容器还具有其他功能，例如size()成员函数可以用于获取数组的大小，fill()成员函数可以用于将所有元素设置为指定值，begin()和end()成员函数可以用于迭代数组中的所有元素。

总之，在C++11中，可以使用array容器代替静态数组。array容器提供了更好的类型安全性和迭代器支持，并具有许多有用的成员函数。

C++中的智能指针

Thu, 02 Mar 2023 12:34:40 +0000

在 C++ 中，指针是一种非常有用的数据类型，但是它们也经常引起内存泄漏和悬空指针等问题。智能指针是一种特殊的指针，它能够自动管理内存，帮助我们避免这些常见的问题。

智能指针是一个对象，它的行为类似于指针，但是它还有一些额外的功能。智能指针可以自动地跟踪对象的生命周期，并在不再需要时释放内存。这种自动化的内存管理使得代码更加健壮和可靠。

C++ 有两种内置的智能指针类型：shared_ptr 和 unique_ptr。shared_ptr 可以跟踪多个指向同一对象的指针，而 unique_ptr 只能有一个指针指向一个对象。shared_ptr 使用引用计数来管理内存，unique_ptr 管理独占所有权。

智能指针的使用非常简单。只需要声明一个智能指针对象，并将其初始化为指向对象的指针。智能指针将负责管理内存，即使在函数返回或抛出异常时也能确保内存被正确释放。

智能指针是一种非常强大的工具，它可以帮助我们编写更加健壮和可靠的 C++ 代码。在编写 C++ 程序时，我们应该尽可能地使用智能指针来管理内存，以避免内存泄漏和悬空指针等问题。

例如，我们可以使用智能指针来管理一个动态分配的对象：

#include <memory>

class MyClass {
public:
 MyClass() { std::cout << "MyClass constructed" << std::endl; }
 ~MyClass() { std::cout << "MyClass destructed" << std::endl; }
 void Print(){}
};

int main() {
 std::shared_ptr<MyClass> myClassPtr(new MyClass());

 // do something with myClassPtr

 return 0;
}

在这个例子中，我们使用 shared_ptr 来管理一个动态分配的 MyClass 对象。当 myClassPtr 超出作用域时，它会自动释放 MyClass 对象的内存。这种自动化的内存管理使得代码更加健壮和可靠。

C++中的构造函数

Thu, 02 Mar 2023 12:34:40 +0000

为什么需要构造函数

构造函数是一种特殊的函数，用于在创建对象时初始化对象的成员变量。它们在对象创建时自动调用，因此它们很有用，可以确保在使用对象之前对象已经被正确地初始化。

构造函数还可以用来设置默认值、分配内存和执行其他必要的初始化步骤，以确保对象能够正常工作。因此，它们是面向对象编程中不可或缺的一部分。

主要是初始化很有用

例如，以下是一个简单的类定义，它包含一个构造函数来初始化一个整数成员变量：

#include <iostream>
class MyClass {
public:
int myInt;
MyClass(int x) {
myInt = x;
}
};
int main() {
MyClass obj(42);
std::cout << obj.myInt << std::endl;
return 0;
}

在这个例子中，我们定义了一个名为MyClass的类，它有一个整数成员变量myInt和一个构造函数，该函数将传递的值分配给myInt。在创建对象时，构造函数将自动调用，从而初始化myInt。在这个例子中，我们创建了一个名为obj的MyClass对象，并将值42传递给构造函数。当我们打印obj.myInt时，将输出42。

默认构造函数

默认构造函数是指一个类的构造函数，如果没有显式定义，编译器就会自动提供。默认构造函数没有参数，它的主要作用是初始化对象的成员变量，将它们设置为默认值。

在C++中，如果定义了带参数的构造函数，编译器就不会自动提供默认构造函数。因此，在需要使用默认构造函数的情况下，必须显式定义它。

例如，以下是一个简单的类定义，它包含一个默认构造函数：

#include <iostream>
class MyClass {
public:
int myInt;
MyClass() {
myInt = 0;
}
};
int main() {
MyClass obj;
std::cout << obj.myInt << std::endl;
return 0;
}

在这个例子中，我们定义了一个名为MyClass的类，它有一个整数成员变量myInt和一个默认构造函数，该函数将myInt设置为0。在创建对象时，构造函数将自动调用，从而初始化myInt。在这个例子中，我们创建了一个名为obj的MyClass对象，并打印了它的myInt成员变量，它的默认值为0。

怎样隐藏构造函数

可以使用访问修饰符来隐藏构造函数，使它们无法从外部访问。例如，将构造函数声明为private将防止在类外部创建对象，但允许类内部的其他函数创建对象。这种技术被称为单例模式，它可以确保只有一个类的实例存在于任何给定的时间。

例如，我们可以创建一个名为Singleton的类，它有一个私有的构造函数和一个公共的静态方法GetInstance，用于获取类的唯一实例。在GetInstance方法中，我们使用一个静态的Singleton指针变量来保存类的唯一实例，并在第一次调用GetInstance时创建它。以后的每次调用都将返回相同的实例，因此只有一个Singleton实例存在于任何给定的时间。

以下是Singleton类的示例代码：

#include <iostream>
class Singleton {
private:
static Singleton* instance;
// 私有构造函数
Singleton() {}
public:
// 静态方法，用于获取唯一实例
static Singleton* GetInstance() {
if (!instance) {
instance = new Singleton();
}
return instance;
}
};
Singleton* Singleton::instance = nullptr;
int main() {
Singleton* obj1 = Singleton::GetInstance();
Singleton* obj2 = Singleton::GetInstance();
// obj1和obj2是同一个对象
std::cout << obj1 << std::endl;
std::cout << obj2 << std::endl;
return 0;
}

在这个例子中，我们定义了一个名为Singleton的类，它有一个私有的构造函数和一个公共的静态方法GetInstance。我们还定义了一个静态的Singleton指针变量instance，用于保存类的唯一实例。

在main函数中，我们首先使用GetInstance方法获取一个名为obj1的Singleton实例，然后再次调用GetInstance方法获取一个名为obj2的Singleton实例。由于GetInstance方法始终返回相同的实例，因此obj1和obj2是相同的对象。我们打印它们的地址，以证明它们是相同的对象。

析构函数

除了构造函数外，C++中还有一个特殊的函数叫做析构函数。析构函数在对象被销毁时自动调用，用于释放对象使用的资源（例如内存）。

在C++中，析构函数的名称是在类名称前面加上一个波浪号（~），例如：

class MyClass {
public:
~MyClass() {
// 析构函数代码
}
};

在这个例子中，我们定义了一个名为MyClass的类，它有一个析构函数。当对象被销毁时，析构函数将自动调用，执行代码以释放使用的资源。

移动构造函数和移动赋值运算符

移动构造函数和移动赋值运算符是C++11引入的新功能，用于提高代码的效率。它们允许将一个对象的资源（例如内存）移动到另一个对象中，而不是进行复制。

移动构造函数在创建新对象时从现有对象中“窃取”资源。移动赋值运算符在将一个对象的值赋给另一个对象时执行相同的操作。

例如，以下是一个简单的类定义，其中包含一个移动构造函数和一个移动赋值运算符：

#include <iostream>
class MyClass {
public:
int* myArray;
int size;
// 移动构造函数
MyClass(MyClass&& other) {
myArray = other.myArray;
size = other.size;
other.myArray = nullptr;
other.size = 0;
}
// 移动赋值运算符
MyClass& operator=(MyClass&& other) {
if (this != &other) {
delete[] myArray;
myArray = other.myArray;
size = other.size;
other.myArray = nullptr;
other.size = 0;
}
return *this;
}
// 构造函数
MyClass(int s) {
myArray = new int[s];
size = s;
}
// 析构函数
~MyClass() {
delete[] myArray;
}
};
int main() {
MyClass obj1(10); // 创建一个对象
MyClass obj2(std::move(obj1)); // 使用移动构造函数创建一个新对象
obj1 = MyClass(20); // 使用移动赋值运算符将一个临时对象的值赋给一个对象
return 0;
}

在这个例子中，我们定义了一个名为MyClass的类，它有一个整数数组成员变量myArray和一个整数成员变量size。我们还定义了一个移动构造函数、一个移动赋值运算符、一个构造函数和一个析构函数。

在main函数中，我们首先创建了一个名为obj1的MyClass对象，然后使用移动构造函数创建了一个名为obj2的新对象。接下来，我们使用移动赋值运算符将一个临时的MyClass对象的值赋给obj1。这些操作允许我们“移动”资源，而不是进行复制，从而提高了代码的效率。

C++中的析构函数

Thu, 02 Mar 2023 12:34:40 +0000

在C++中，析构函数是一种特殊类型的函数，它在对象生命周期结束时被调用。析构函数的作用是清理对象在其生命周期中使用的资源，例如动态分配的内存和打开的文件等。因此，它是C++中重要的特性之一。

在类定义中，析构函数的名称是与类名相同，前面加上一个波浪号(~)。如下所示：

class MyClass {
public:
// 构造函数
MyClass() {
// 对象创建时执行
}
// 析构函数
~MyClass() {
// 对象销毁时执行
}
};

当对象超出其作用域或被显式地删除时，析构函数将被调用。例如：

int main() {
MyClass obj;
// 对象超出作用域
return 0;
}
或
int main() {
MyClass *ptr = new MyClass();
// 显式地删除对象
delete ptr;
return 0;
}

当执行以上代码时，MyClass的析构函数将被自动调用，以便清理对象在其生命周期中使用的资源。

需要注意的是，当一个对象被销毁时，它的成员变量和基类也将被销毁。因此，在析构函数中，通常需要对所有成员变量和基类进行清理操作。

总之，析构函数是C++中非常重要的特性之一，它允许程序员在对象生命周期结束时清理对象所使用的资源。在编写C++程序时，需要了解析构函数的使用和语法，以便正确地管理程序所使用的资源。

不推荐手动调用析构函数

C++中的枚举

Thu, 02 Mar 2023 12:34:40 +0000

在C++中，枚举是一种用户自定义的数据类型，它允许程序员定义一组命名的常量。这些常量可以被当作整数使用，并且在程序中具有固定的值。

在C++中，要定义一个枚举，需要使用关键字’enum’。下面是一个例子：

enum Season {Spring, Summer, Fall, Winter};

在这个例子中，我们定义了一个名为’Season’的枚举类型，其中包含了四个常量：Spring，Summer，Fall和Winter。这些常量的值分别为0，1，2和3。如果需要改变这些常量的值，可以显式地指定它们的值，如下所示：

enum Season {Spring=1, Summer=2, Fall=3, Winter=4};

在这个例子中，我们将Spring的值指定为1，Summer的值指定为2，依此类推。

枚举常量的值可以在程序中使用，例如：

Season currentSeason = Summer;
if (currentSeason == Summer) {
cout << "It's Summer!" << endl;
}

在这个例子中，我们将currentSeason的值设为Summer，然后检查它是否等于Summer。如果是，就输出"It’s Summer!"。

枚举类型还可以用于switch语句，例如：

switch(currentSeason) {
case Spring:
cout << "It's Spring!" << endl;
break;
case Summer:
cout << "It's Summer!" << endl;
break;
case Fall:
cout << "It's Fall!" << endl;
break;
case Winter:
cout << "It's Winter!" << endl;
break;
}

在这个例子中，我们使用switch语句检查currentSeason的值，并根据其值输出相应的信息。

总之，枚举是C++中一种非常有用的数据类型，它可以帮助我们定义一组常量，并在程序中使用它们。

C++中的继承

Thu, 02 Mar 2023 12:34:40 +0000

C++中的继承

继承是面向对象编程中的一个重要概念，C++作为一门面向对象编程语言，支持类的继承。子类可以继承父类的属性和方法，从而避免了代码的重复编写，提高了代码的可重用性。

C++中的继承有以下几种类型：

公有继承（public inheritance）

公有继承是指子类继承父类的公有成员，父类的私有成员和保护成员不能被子类访问。

私有继承（private inheritance）

私有继承是指子类继承父类的私有成员和保护成员，但不能访问父类的公有成员。私有继承主要用于实现“has-a”关系。

保护继承（protected inheritance）

保护继承是指子类继承父类的保护成员和公有成员，但不能访问父类的私有成员。保护继承主要用于实现“is-a”关系。

在C++中，子类可以通过继承的方式获得父类的所有成员，包括数据成员和成员函数。在子类中可以通过父类名::成员名的方式来访问父类的成员。同时，C++中还支持虚继承和多重继承等高级特性，可以更加灵活地设计类的继承关系。

继承是C++面向对象编程中的重要概念，掌握继承的原理和用法对于设计高质量的面向对象程序非常重要。

例如，我们有一个 Animal 类，里面包含了 name 和 age 两个属性以及 eat() 和 sleep() 两个方法。现在，我们需要实现一个 Dog 类，它继承自 Animal 类，并且还有一个 bark() 方法。我们可以这样定义 Dog 类：

class Animal {
public:
string name;
int age;
void eat() {
cout << "I am eating." << endl;
}
void sleep() {
cout << "I am sleeping." << endl;
}
};

class Dog : public Animal {
public:
void bark() {
cout << "Woof!" << endl;
}
};

这样，Dog 类就继承了 Animal 类的属性和方法，并且还新增了一个 bark() 方法。我们可以这样使用 Dog 类：

Dog myDog;
myDog.name = "Fido";
myDog.age = 3;
myDog.eat();
myDog.sleep();
myDog.bark();

这样就可以创建一个 Dog 对象，并且调用它的属性和方法了。

在C++中，继承关系会影响成员的可见性。具体来说，成员的可见性取决于它在父类中的访问权限以及继承方式。

如果使用公有继承，在子类中可以访问父类的公有成员和受保护的成员，但不能访问父类的私有成员。如果使用私有继承，在子类中可以访问父类的受保护的成员和私有成员，但不能访问父类的公有成员。如果使用保护继承，在子类中可以访问父类的公有成员和受保护的成员，但不能访问父类的私有成员。

需要注意的是，在子类中可以通过父类名::成员名的方式来访问父类的成员，不受继承方式的限制。此外，如果在子类中定义了与父类同名的成员函数或成员变量，则会覆盖父类的同名成员，这被称为函数重载或变量隐藏。

继承是C++面向对象编程中的重要概念，掌握继承的原理和用法对于设计高质量的面向对象程序非常重要。

C++虚函数

Thu, 02 Mar 2023 12:34:40 +0000

C++中的虚函数是一种在运行时动态绑定的机制。虚函数使得C++中的多态性成为可能，因为它允许在运行时选择正确的函数实现。

在C++中，虚函数是通过在基类函数声明前面添加关键字“virtual”来声明的。当派生类继承该函数时，如果它重写了该函数并且在派生类函数声明前面也加上了“virtual”关键字，那么该函数就变成了虚函数。派生类中的虚函数实现将覆盖基类中的虚函数实现，从而实现了运行时多态性。

虚函数的工作原理是通过虚函数表来实现的。每个包含虚函数的类都有一个指向虚函数表的指针，虚函数表是一个包含该类中虚函数指针的数组。当调用虚函数时，程序会查找对象的虚函数表，然后根据表中存储的函数指针调用正确的函数实现。

虚函数在C++中的使用非常普遍，特别是在面向对象编程中。它使得代码更加模块化和可扩展，并且提高了代码的可维护性和可读性。

总之，虚函数是C++中一种重要的机制，它允许在运行时动态绑定函数实现，从而实现多态性。对于任何想要在C++中编写高效且易于维护的代码的开发者来说，了解和掌握虚函数的使用是非常重要的。

以下是一个虚函数的简单示例，演示了如何在派生类中重写基类中的虚函数：

#include <iostream>

class Base {
public:
 **virtual** void say_hello() {
 std::cout << "Hello from Base" << std::endl;
 }
};

class Derived : public Base {
public:
 void say_hello() override {
 std::cout << "Hello from Derived" << std::endl;
 }
};

int main() {
 Base* b = new Derived();
 b->say_hello(); // 输出 "Hello from Derived"
 delete b;
 return 0;
}

在这个例子中，我们有一个基类 Base，它有一个名为 say_hello 的虚函数。我们还有一个派生类 Derived，它重写了 say_hello 函数。在 main 函数中，我们首先创建了一个 Derived 类型的对象，然后将其赋值给一个指向基类的指针 b。接下来，我们调用 b 的 say_hello 函数。由于 say_hello 是虚函数，程序会在运行时选择正确的函数实现，即 Derived 类中的 say_hello 函数。因此，程序将输出 “Hello from Derived”。

其实就是base class 里边有个函数可以在 sub class 里重写，给了个标记 virtual, 告诉编译器，生成 v表吧，为这个函数。这样如果它被重写了，你就可以指向正确的函数

C++11 override关键字

C++11中加入了一个新的关键字 override，用于表示派生类中的函数是重写了基类中的虚函数。使用 override 可以帮助我们避免因为函数签名不一致而无法正确重写虚函数的问题。如果派生类中的函数没有正确重写基类中的虚函数，编译器将会报错。

以下是使用 override 关键字的示例：

#include <iostream>
class Base {
public:
virtual void say_hello() {
std::cout << "Hello from Base" << std::endl;
}
};
class Derived : public Base {
public:
void say_hello() override {
std::cout << "Hello from Derived" << std::endl;
}
// 如果这里不加 override 关键字，编译器将会报错
};
int main() {
Base* b = new Derived();
b->say_hello(); // 输出 "Hello from Derived"
delete b;
return 0;
}

在这个例子中，我们在 Derived 类中重写了 say_hello 函数，并使用了 override 关键字。如果我们不加 override 关键字，编译器将会报错。

虚函数相关的运行成本

虚函数的使用可能会带来一些额外的运行时开销。两个

由于每个包含虚函数的类都需要一个指向虚函数表的指针，这会增加对象的大小。
此外，在调用虚函数时，程序需要查找对象的虚函数表并调用正确的函数实现，这可能会导致一些性能损失。

然而，这些开销通常是可以接受的，并且通过合理的设计和实现可以最小化这些开销。在大多数情况下，虚函数的使用对于代码的可维护性和可扩展性来说是非常重要的，因此我们应该仔细考虑是否需要使用虚函数。

CPP

Thu, 02 Mar 2023 12:34:40 +0000

C++ is a high-level, general-purpose programming language that was developed by Bjarne Stroustrup in 1983 as an extension of the C programming language. C++ provides support for object-oriented programming, generic programming, and low-level memory manipulation.

One of the main advantages of C++ is its efficiency and performance. C++ code can be compiled into machine code, which makes it faster than other high-level programming languages. This makes it a popular choice for developing high-performance software such as video games, operating systems, and scientific simulations.

Another advantage of C++ is its flexibility. It can be used for a wide range of applications, from desktop applications to mobile apps, and from large-scale enterprise systems to small-scale embedded systems.