快速入门c++
基础篇
一、类（class）
1.概念
在 C++ 中，类（class）是一种用于创建对象的蓝图或模板。类定义了对象的属性（成员变量）和行为（成员函数），并提供了一种封装数据和功能的机制。
2.案例
(1).构造函数
构造函数是一种特殊的成员函数，用于初始化类的对象。构造函数的名称与类名相同，并且没有返回类型（包括 void）。构造函数在创建对象时自动调用，用于设置对象的初始状态。
(2).成员访问修饰符
类的成员可以使用访问修饰符（public、private、protected）来指定其访问权限。public修饰的公有成员可以在类的外部访问，private修饰的私有成员只能在类的内部访问，protected修饰的受保护成员可以在类的内部和派生类中访问。
#include <iostream>
#include <string>
class Person {
// 私有变量
private:
std::string name;
int age;
// 公有变量
public:
// 构造函数
Person(const std::string& n, int a) : name(n), age(a) {}
// 成员函数
void display() {
std::cout << "Name: " << name << ", Age: " << age << std::endl;
}
};
int main() {
// 创建类对象
Person person("John", 25);
// 调用成员函数
person.display();
return 0;
}
(3).继承
类可以通过继承从其他类派生，从而获得已有类的属性和行为。继承可以形成类的层次结构，提供代码重用和多态性的机制。
#include <iostream>
#include <string>
class Person {
protected:
std::string name;
int age;
public:
// 构造函数
Person(const std::string &n, int a) : name(n), age(a) {}
// 成员函数
void display() {
std::cout << "Name: " << name << ", Age: " << age << std::endl;
}
};
//Student继承Person
//注意private修饰的变量不能被继承
class Student : public Person {
private:
std::string grade;
public:
// 构造函数
Student(const std::string &n, int a, const std::string &g)
: Person(n, a), grade(g) {}
// 成员函数
void display() {
Person::display();
std::cout << "Grade: " << grade << std::endl;
}
void study() { std::cout << name << " is studying." << std::endl; }
};
int main() {
// 创建类对象
Student student("Alice", 20, "A");
// 调用成员函数
student.display();
student.study();
return 0;
}(4).静态成员
静态成员使用关键字 "static" 来表示。通过将成员变量或成员函数声明为静态，它们将与类本身相关联，而不是与类的对象相关联。
#include <iostream>
class MyClass {
public:
static int count; // 静态成员变量
static void displayCount() { // 静态成员函数
std::cout << "Count: " << count << std::endl;
}
};
int MyClass::count = 0; // 静态成员变量的定义和初始化
int main() {
MyClass::count = 5; // 访问和修改静态成员变量
MyClass::displayCount(); // 调用静态成员函数
return 0;
}
在上面的示例中，我们定义了一个名为 "MyClass" 的类，并声明了一个静态成员变量 "count" 和一个静态成员函数 "displayCount"。静态成员变量 "count" 在类的定义中使用 "static" 关键字进行声明，然后在类外部进行定义和初始化。静态成员函数 "displayCount" 也使用 "static" 关键字进行声明。
在主函数中，我们通过类名和作用域运算符 "::" 来访问和修改静态成员变量 "count"，以及调用静态成员函数 "displayCount"。
需要注意的是，静态成员变量和静态成员函数不依赖于类的对象，可以在没有创建类对象的情况下直接访问和使用。静态成员变量在内存中只有一份拷贝，被所有类的对象共享。静态成员函数也不具有隐式的 this 指针，因为它们没有与特定对象关联。
静态成员在某些情况下很有用，例如用于跟踪类的实例数量、在类的所有对象之间共享数据等。它们提供了一种在类级别上操作和管理数据的机制。
(5).重载
类的重载是指在同一个类中定义多个具有相同名称但参数列表不同的成员函数。通过函数重载，可以根据不同的参数类型或参数个数来调用不同的函数。
类的成员函数可以被重载，包括构造函数和普通成员函数。构造函数的重载可以用于创建不同类型或不同参数的对象。普通成员函数的重载可以提供多个具有相似功能但参数不同的函数。
#include <iostream>
class MyClass {
public:
void display() {
std::cout << "Display function without arguments." << std::endl;
}
void display(int num) {
std::cout << "Display function with argument: " << num << std::endl;
}
void display(double num1, double num2) {
std::cout << "Display function with arguments: " << num1 << " and " << num2 << std::endl;
}
};
int main() {
MyClass obj;
obj.display(); // 调用无参数的 display 函数
obj.display(42); // 调用带一个整数参数的 display 函数
obj.display(3.14, 2.71); // 调用带两个双精度参数的 display 函数
return 0;
}
在上面的代码中，类 "MyClass" 定义了三个名为 "display" 的成员函数，它们具有不同的参数列表。在主函数中，我们创建了一个 "MyClass" 的对象 "obj"，并通过不同的函数调用来演示函数重载的效果。
这表明在同一个类中，我们可以定义多个具有相同名称但参数列表不同的成员函数。通过根据调用时提供的参数类型或参数个数来选择合适的函数，可以实现函数重载的效果。
(6).析构函数
析构函数（Destructor）是一种特殊的成员函数，用于在对象被销毁时执行清理操作。它的名称与类名相同（注意和构造函数区分），前面加上一个波浪号（~）作为前缀，没有返回类型，也没有参数。
当对象超出其作用域、被显式删除或程序结束时，析构函数会自动调用。它用于释放对象所占用的资源，例如动态分配的内存、打开的文件或建立的网络连接等。
#include <iostream>
class MyClass {
public:
MyClass() {
std::cout << "Constructor called." << std::endl;
}
~MyClass() {
std::cout << "Destructor called." << std::endl;
}
};
int main() {
{
MyClass obj; // 创建一个对象
}
// 这里对象超出作用域，析构函数被调用，所以先显示Destructor called再显示Destructor called
std::cout << "Program ends." << std::endl;
return 0;
}
在上面的代码中，类 "MyClass" 定义了一个构造函数和一个析构函数。在主函数中，我们创建了一个 "MyClass" 的对象 "obj"，并在其作用域结束后，析构函数会被自动调用。
运行程序将输出：
Constructor called.
Destructor called.
Program ends.
这表明在对象超出作用域时，析构函数会被自动调用。在本例中，当对象 "obj" 超出其作用域时，析构函数被调用，并打印出相应的消息。最后，程序结束时也会调用析构函数。
析构函数的作用是清理对象所占用的资源，例如释放内存、关闭文件或断开网络连接等。通过析构函数，可以确保在对象不再需要时进行必要的清理操作，避免资源泄漏和内存泄漏等问题。
三、结构体（struct）
1.概念
结构体（struct）是一种用户自定义的数据类型，它可以包含多个不同类型的成员变量。与类（class）相比，结构体的成员默认是公有的（public），而类的成员默认是私有的（private）。
结构体可以用于组织相关的数据，并且可以在一个结构体中定义函数（成员函数）来操作这些数据。结构体的语法如下：
struct 结构体名称 {
// 成员变量
类型 成员变量1;
类型 成员变量2;
// ...
// 成员函数
返回类型 成员函数1(参数列表) {
// 函数体
}
返回类型 成员函数2(参数列表) {
// 函数体
}
// ...
};
2.示例
(1).简单示例
#include <iostream>
// 定义一个Person结构体
struct Person{
// 成员变量
char *name;
int age;
// 成员函数
void sayName(){
std::cout<<"my name is:"<<name<<std::endl;
}
};
int main() {
Person person = {"pan",18};
std::cout << person.name << std::endl;
std::cout << person.age << std::endl;
person.sayName();
return 0;
}
输出
pan
18
my name is:pan
在上面的示例中，我们定义了一个Person的结构体，他有两个成员变量name和age，和一个成员函数sayName()。
(2).结构体赋值方法
// 结构体赋值方法1，不推荐不能明确指定参数是哪个
// Person person = {"zhang",18};
// 结构体赋值方法2，推荐
// Person person = {.name="zhang",.age=18};
// 结构体赋值方法3，推荐
Person person = {name:"z",age:18};
二、数组（array）
1.声明一个数组并且存值
//定义一个int类型的长度为10的数组
int arr[10];
//给数组首位存值
arr[0] = 1;
也可以定义chat string类型的数组
2.直接初始化数组
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
3.数组的输出是一个地址
std::cout << arr << std::endl; //输出的是地址：0x61fdf0
4.数组的长度计算
在c++中数组没有直接的方法输出数组的长度，我们可以自己手动实现
sizeof(arr)可以获取整个数组的字节大小
sizeof(arr[0])可以获取单个数组元素的字节大小
sizeof(arr)/size(arr[0])就可以计算出数组的长度
在这里可以写一个模版函数用于计算数组的长度
template <typename T>
//传入数组的地址
int length(T &arr){
return sizeof(arr) / sizeof(arr[0]);
}
5.下面展示一个完整的例子
#include <iostream>
#include <string>
using namespace std;
template <typename T>
int length(T &arr) {
return sizeof(arr) / sizeof(arr[0]);
}
int main() {
// int arr[10];
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
arr[0] = 1;
std::cout << arr << std::endl;
for (int i = 0; i < length(arr); i++) {
std::cout << arr[i] << std::endl;
}
return 0;
}注意输入的arr是一个地址，在c++中要输出整个数组要借助for循环
———————————————————关注收藏持续更新