专业网站设计制作,大型网站开发语言排名,.tv可以做门户网站不,做一个小网站需要多少钱一、深入讲解构造函数
1. 什么是构造函数#xff1f;
构造函数#xff08;Constructor#xff09;是在创建对象时自动调用的特殊成员函数#xff0c;用于初始化对象的成员变量。构造函数的名称与类名相同#xff0c;没有返回类型
2. 构造函数的类型
#xff08;1
构造函数Constructor是在创建对象时自动调用的特殊成员函数用于初始化对象的成员变量。构造函数的名称与类名相同没有返回类型
2. 构造函数的类型
1默认构造函数
没有参数或所有参数都有默认值的构造函数
class Person {
public:Person() {name Unknown;age 0;}
private:std::string name;int age;
};
2有参构造函数
接受参数用于自定义初始化对象的构造函数
class Person {
public:Person(const std::string name, int age) : name(name), age(age) {}
private:std::string name;int age;
};
3拷贝构造函数
用于创建对象的副本
class Person {
public:Person(const Person other) : name(other.name), age(other.age) {std::cout 拷贝构造函数被调用 std::endl;}
private:std::string name;int age;
};
4移动构造函数C11 引入
用于移动资源避免不必要的拷贝
class Person {
public:Person(Person other) noexcept : name(std::move(other.name)), age(other.age) {std::cout 移动构造函数被调用 std::endl;}
private:std::string name;int age;
};
3. 构造函数的初始化列表
使用初始化列表可以在构造函数中直接初始化成员尤其是常量成员或引用类型的成员
class Person {
public:Person(const std::string name, int age) : name(name), age(age) {}
private:const std::string name;int age;
};
4. 构造函数的调用顺序
基类构造函数先于派生类构造函数被调用成员对象的构造函数按照它们在类中声明的顺序被调用
5. 代码示例
#include iostream
#include stringclass Address {
public:Address(const std::string city) : city(city) {std::cout Address 构造 std::endl;}
private:std::string city;
};class Person {
public:Person() : name(Unknown), age(0), address(Unknown City) {std::cout Person 默认构造 std::endl;}Person(const std::string name, int age, const std::string city): name(name), age(age), address(city) {std::cout Person 有参构造 std::endl;}Person(const Person other): name(other.name), age(other.age), address(other.address) {std::cout Person 拷贝构造 std::endl;}private:std::string name;int age;Address address;
};int main() {Person p1;Person p2(Alice, 30, New York);Person p3 p2;return 0;
}
二、深入理解封装
1. 什么是封装
封装Encapsulation是将数据和操作数据的方法绑定在一起保护对象的内部状态不被外部直接访问和修改。它是面向对象编程的基本特性之一
2. 访问控制符
public公共成员外部可以访问protected受保护成员派生类可以访问private私有成员只有类内部可以访问
3. 为什么需要封装
提高代码的安全性防止数据被非法访问和修改隐藏内部实现细节提供清晰的接口便于维护和扩展代码
4. 通过方法访问私有成员
class BankAccount {
public:BankAccount(double balance) : balance(balance) {}void deposit(double amount) {if (amount 0) {balance amount;}}bool withdraw(double amount) {if (amount 0 balance amount) {balance - amount;return true;}return false;}double getBalance() const {return balance;}private:double balance;
};
5. 代码示例
#include iostreamclass Rectangle {
public:void setWidth(double w) {if (w 0)width w;}void setHeight(double h) {if (h 0)height h;}double getArea() const {return width * height;}private:double width;double height;
};int main() {Rectangle rect;rect.setWidth(10);rect.setHeight(5);std::cout 面积 rect.getArea() std::endl;return 0;
}
三、static 成员
1. 什么是 static 成员
在类中用 static 关键字修饰的成员称为静态成员。它们属于类本身而不是某个对象
2. 静态成员变量
所有对象共享同一份静态成员变量必须在类外进行定义和初始化
class Counter {
public:Counter() {count;}static int getCount() {return count;}private:static int count;
};int Counter::count 0;
3. 静态成员函数
只能访问静态成员变量和其他静态成员函数可以在不创建对象的情况下调用
class Math {
public:static double pi() {return 3.14159;}
};
4. 代码示例
#include iostreamclass Student {
public:Student(const std::string name) : name(name) {totalStudents;}~Student() {--totalStudents;}static int getTotalStudents() {return totalStudents;}private:std::string name;static int totalStudents;
};int Student::totalStudents 0;int main() {std::cout 当前学生人数 Student::getTotalStudents() std::endl;Student s1(Alice);Student s2(Bob);std::cout 当前学生人数 Student::getTotalStudents() std::endl;{Student s3(Charlie);std::cout 当前学生人数 Student::getTotalStudents() std::endl;}std::cout 当前学生人数 Student::getTotalStudents() std::endl;return 0;
}
四、友元friend
1. 什么是友元
友元是被类授予访问其私有和保护成员权限的函数或类。使用 friend 关键字声明
2. 友元函数
可以是普通函数或者类的成员函数在类内声明在类外定义
class Box {
private:double width;public:friend void setWidth(Box b, double w);
};void setWidth(Box b, double w) {b.width w;
}
3. 友元类
一个类可以将另一个类声明为友元从而该友元类的成员函数可以访问本类的私有和保护成员
class Engine;class Car {
private:int speed;friend class Engine;
};class Engine {
public:void setSpeed(Car car, int s) {car.speed s;}
};
4. 友元的用途
当需要某个函数或类访问另一个类的私有成员时应谨慎使用避免破坏封装性
5. 代码示例
#include iostreamclass Secret {
private:std::string password;public:Secret(const std::string pwd) : password(pwd) {}friend void reveal(const Secret s);
};void reveal(const Secret s) {std::cout 秘密是 s.password std::endl;
}int main() {Secret s(123456);reveal(s);return 0;
}
五、内部类嵌套类
1. 什么是内部类
在一个类的定义中定义另一个类称为内部类或嵌套类
2. 内部类的特性
内部类可以访问外部类的私有和保护成员外部类需要通过对象来访问内部类的成员
3. 什么时候使用内部类
当某个类只为另一个类服务时为了更好地组织代码提升封装性
4. 代码示例
#include iostreamclass Outer {
private:int outerData;public:Outer(int data) : outerData(data) {}class Inner {public:void displayOuterData(const Outer o) {std::cout 外部类数据 o.outerData std::endl;}};
};int main() {Outer o(100);Outer::Inner i;i.displayOuterData(o);return 0;
}
六、匿名对象
1. 什么是匿名对象
没有被命名的临时对象通常在表达式中创建使用完后立即销毁
2. 匿名对象的用途
作为函数的返回值或参数进行临时运算
3. 代码示例
#include iostreamclass Number {
public:Number(int value) : value(value) {std::cout 构造 value std::endl;}~Number() {std::cout 析构 value std::endl;}int getValue() const {return value;}private:int value;
};Number createNumber(int x) {return Number(x);
}int main() {Number(10); // 创建匿名对象std::cout -------- std::endl;Number n createNumber(20);std::cout n 的值 n.getValue() std::endl;return 0;
}
七、拷贝对象时的一些编译器优化
1. 什么是拷贝消除
编译器优化的一种避免不必要的对象拷贝提高性能
2. 返回值优化RVO
当函数返回对象时直接在调用者的空间构造对象避免临时对象的生成
class Data {
public:Data() {std::cout Data 构造 std::endl;}Data(const Data) {std::cout Data 拷贝构造 std::endl;}~Data() {std::cout Data 析构 std::endl;}
};Data getData() {Data d;return d;
}int main() {Data d getData();return 0;
}
3. 使用 std::move 和移动语义
在需要移动对象而非拷贝时使用 std::move
#include vector
#include stringint main() {std::vectorstd::string vec;std::string str Hello;vec.push_back(std::move(str)); // 移动 str而不是拷贝return 0;
}
4. 代码示例
#include iostreamclass Example {
public:Example() {std::cout 构造函数 std::endl;}Example(const Example) {std::cout 拷贝构造函数 std::endl;}Example(Example) noexcept {std::cout 移动构造函数 std::endl;}~Example() {std::cout 析构函数 std::endl;}
};Example createExample() {Example e;return e;
}int main() {Example e createExample();return 0;
}
