C++ 基础与核心编程：指针、内存及面向对象

C++ 基础与核心编程：指针、内存及面向对象 | 极客日志

int arr[3] = {10, 20, 30}; 
// 1. 数组名：统计数组字节大小
cout << sizeof(arr); // 输出 12（3 个 int，每个 4 字节）
cout << sizeof(arr[0]); // 输出 4（首元素的大小）

// 2. 数组地址和数组元素的首地址
// arr 和&arr 两者在值上是相等的，但是本质不同
// arr（首元素地址）的类型是 int*（指向 int 的指针），步长是 sizeof(int)=4 字节。
// &arr（整个数组地址）的类型是 int (*)[3]（指向 int[3] 数组的指针），步长是 sizeof(int[3])=12 字节
cout << "&arr（整个数组地址）：" << &arr << endl;
cout << "arr（首元素地址）：" << arr << endl;

int arr[2][3] = {{1, 2, 3}, {4, 5, 6}}; 
// 1. 数组名：统计整个二位数组字节大小
cout << sizeof(arr); // 输出 24（2 个子数组 × 3 个 int × 4 字节/int）

// 2. 数组名：指向一维数组
int (*p)[3] = arr; // 等价于 p = &arr[0]（arr[0] 是第一个一维子数组）
cout << (*p)[0]; // 输出 1（访问第一个子数组的第 0 个元素）
cout << (*(p+1))[0]; // 输出 4（p+1 指向第二个子数组，步长是 sizeof(int[3])=12 字节）

// 3. 整个二位数组地址：&数组名
int (*p_arr)[2][3] = &arr;

// 4. 数组名 + 下标（如 arr[0]）—— 是'一维数组的数组名'
int* p_elem = arr[0]; // 等价于 p_elem = &arr[0][0]
cout << *p_elem; // 输出 1

#include <stdio.h> 
// 示例 1：未优化的成员顺序（有填充字节）
struct Unoptimized { 
    char a; // 1 字节
    int b;  // 4 字节
    short c;// 2 字节
}; 

// 示例 2：优化后的成员顺序（减少填充）
struct Optimized { 
    char a; // 1 字节
    short c;// 2 字节
    int b;  // 4 字节
}; 

int main() { 
    printf("Unoptimized size: %zu bytes\n", sizeof(struct Unoptimized)); 
    printf("Optimized size: %zu bytes\n", sizeof(struct Optimized)); 
    return 0; 
}

Unoptimized size: 12 bytes
Optimized size: 8 bytes

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

// 定义 Person 类，包含构造、拷贝构造、析构函数
class Person { 
private: 
    string name; // 姓名
    int age;     // 年龄
public: 
    // 1. 无参构造函数（默认构造）
    // 如果不手动定义，编译器会自动生成空的无参构造
    Person() { 
        cout << "调用【无参构造函数】" << endl; 
        name = "未知"; 
        age = 0; 
    } 
    
    // 2. 有参构造函数
    // 自定义参数初始化成员变量
    Person(string n, int a) { 
        cout << "调用【有参构造函数】" << endl; 
        name = n; 
        age = a; 
    } 
    
    // 3. 拷贝构造函数
    // 用已有对象初始化新对象，参数必须是 const 引用（const 防止修改原对象，引用避免无限递归）
    Person(const Person& p) { 
        cout << "调用【拷贝构造函数】" << endl; 
        // 把原对象 p 的成员值复制给新对象
        name = p.name; 
        age = p.age; 
    } 
    
    // 4. 析构函数
    // 对象销毁时自动调用，用于释放资源（如堆内存、文件句柄等）
    // 无参数、无返回值，名称是~类名
    ~Person() { 
        cout << "调用【析构函数】，销毁对象：" << name << endl; 
    } 
    
    // 成员函数：打印对象信息，方便验证
    void showInfo() { 
        cout << "姓名：" << name << "，年龄：" << age << endl; 
    } 
}; 

// 测试函数：验证拷贝构造的调用场景（值传递参数）
void testCopy(Person p) { 
    p.showInfo(); 
} 

int main() { 
    // ========== 1. 调用无参构造 ==========
    cout << "--- 创建无参对象 p1 ---" << endl; 
    Person p1; 
    p1.showInfo(); 
    
    // ========== 2. 调用有参构造 ==========
    cout << "\n--- 创建有参对象 p2 ---" << endl; 
    Person p2("张三", 20); 
    p2.showInfo(); 
    
    // ========== 3. 调用拷贝构造 ==========
    cout << "\n--- 用 p2 拷贝创建 p3 ---" << endl; 
    Person p3 = p2; // 场景 1：用已有对象初始化新对象
    p3.showInfo(); 
    
    cout << "\n--- 函数参数值传递调用拷贝构造 ---" << endl; 
    testCopy(p2); // 场景 2：函数参数为值传递时，拷贝构造新对象
    
    // ========== 4. 析构函数调用 ==========
    // 程序结束时，栈上的对象会按'先创建后销毁'的顺序调用析构
    cout << "\n--- 程序结束，对象开始销毁 ---" << endl; 
    return 0; 
}

#include <iostream> 
using namespace std; 

class Person { 
public: 
    int age; 
    void setAge(int age) { 
        // this->age：指向当前对象的成员变量 age
        // age：函数的形参 age
        this->age = age; 
    } 
    void showAge() { 
        // 即使没有命名冲突，this 也在默默工作
        // 等价于 cout << this->age << endl;
        cout << "年龄：" << age << endl; 
    } 
}; 

int main() { 
    Person p1, p2; 
    // 调用 p1 的 setAge，this 指向 p1
    p1.setAge(18); 
    // 调用 p2 的 setAge，this 指向 p2
    p2.setAge(20); 
    p1.showAge(); // 输出：18（this 指向 p1）
    p2.showAge(); // 输出：20（this 指向 p2）
    return 0; 
}

#include <iostream> 
using namespace std; 

class Person { 
public: 
    int age; 
    // 返回对象本身的引用，支持链式调用
    Person& addAge(int num) { 
        this->age += num; 
        return *this; // *this 就是当前对象本身
    } 
}; 

int main() { 
    Person p; 
    p.age = 10; 
    // 链式调用：连续调用 addAge
    p.addAge(5).addAge(3); 
    cout << p.age << endl; // 输出：18（10+5+3）
    return 0; 
}

void Person::showAddr() { 
    cout << "当前对象的地址：" << this << endl; // 输出对象的内存地址
    cout << "当前对象的年龄：" << (*this).age << endl; // *this 等价于对象本身
}

class Test { 
public: 
    void func1() { 
        cout << "无成员变量访问" << endl; 
    } 
    void func2() { 
        cout << this->age << endl; 
    } 
    int age; 
}; 

int main() { 
    Test* p = NULL; 
    p->func1(); // 不会崩溃（输出：无成员变量访问）
    // p->func2(); // 崩溃！NULL 指针访问成员变量
    return 0; 
}

#include <iostream> 
using namespace std; 

// 函数重载：同一个函数名，参数列表不同（静态多态）
class Calculator { 
public: 
    // 计算两个 int 的和
    int add(int a, int b) { 
        return a + b; 
    } 
    // 计算三个 int 的和（参数个数不同）
    int add(int a, int b, int c) { 
        return a + b + c; 
    } 
    // 计算两个 double 的和（参数类型不同）
    double add(double a, double b) { 
        return a + b; 
    } 
}; 

int main() { 
    Calculator calc; 
    // 编译时就确定调用哪个 add 函数
    cout << calc.add(1, 2) << endl; // 调用 2 个 int 参数的 add，输出 3
    cout << calc.add(1, 2, 3) << endl; // 调用 3 个 int 参数的 add，输出 6
    cout << calc.add(1.5, 2.5) << endl; // 调用 2 个 double 参数的 add，输出 4.0
    return 0; 
}

#include <iostream> 
using namespace std; 

// 父类：动物
class Animal { 
public: 
    // 虚函数：动物叫（核心，开启动态多态）
    virtual void makeSound() { 
        cout << "未知动物的叫声" << endl; 
    } 
    // 析构函数也建议设为虚函数（避免子类析构不执行）
    virtual ~Animal() {} 
}; 

// 子类：猫
class Cat : public Animal { 
public: 
    // 重写父类的虚函数（override 可选，建议加，编译器会检查重写是否正确）
    void makeSound() override { 
        cout << "喵喵喵" << endl; 
    } 
}; 

// 子类：狗
class Dog : public Animal { 
public: 
    void makeSound() override { 
        cout << "汪汪汪" << endl; 
    } 
}; 

// 统一的接口函数（接收父类引用）
void animalCry(Animal &animal) { 
    animal.makeSound(); // 运行时确定调用哪个子类的函数
} 

int main() { 
    Cat cat; 
    Dog dog; 
    // 父类引用指向子类对象，调用不同的 makeSound
    animalCry(cat); // 输出：喵喵喵
    animalCry(dog); // 输出：汪汪汪
    
    // 父类指针指向子类对象（另一种方式）
    Animal *p1 = &cat; 
    p1->makeSound(); // 输出：喵喵喵
    Animal *p2 = &dog; 
    p2->makeSound(); // 输出：汪汪汪
    return 0; 
}

C++ 基础与核心编程：指针、内存及面向对象

C++ 基础与核心编程

C++ 基础

sizeof 和 strlen 的区别

三目运算符

一维数组名作用

二维数组名作用

函数的声明

指针和引用的区别

空指针和野指针

const 关键字

指针和数组

指针和函数

结构体

结构体对齐面试常考知识点

volatile 关键字

static 关键字

define 与 const 区别

new/delete 与 malloc/free 区别

define 与 typedef 区别

C++ 核心编程：封装、继承与多态

封装：类

类与结构体的区别

继承

构造函数

构造函数调用规则

析构函数

深拷贝和浅拷贝

静态成员

非常关键内容

this 指针（本质相当于指向类对象的指针常量）

友元

继承

继承方式

继承中的构造和析构

菱形继承

多态

分类

虚函数和纯虚函数

STL

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具