c++ 语法 类和对象

最新推荐文章于 2024-09-02 20:21:30 发布
最新推荐文章于 2024-09-02 20:21:30 发布
阅读量374 收藏 6
点赞数 10
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38432324/article/details/135987213
版权

类的特性： 封装，继承，多态

封装：

将属性和行为作为一个整体，表现生活中的事务

将属性和行为加以权限控制

语法

class 类名{访问权限：属性/行为}

//
//  main.cpp
//  cpplearn
//
//  Created by KING on 2024/2/1.
//

#include <iostream>
#include "mathutil.hpp"
#include <string>
using namespace std;
const double PI = 3.14;
class Circle {
    //访问权限
    
public:
    //属性
    double m_r;
    //行为
    double caculate() {
        return 2 * m_r * PI;
    }
    
};

class Person {
    // 属性 成员属性 成员变量
    //行为 成员函数 方法
private:
    string m_name;
    int  cardId;
    int  m_age;
public:
    
    string getName() {
        return m_name;
    }
    
    int getCardId() {
        return cardId;
    }
    
    void personInfo() {
        std::cout << m_name << "cardID =" << cardId << std::endl;
    }
    
    void setAge(int age) {
        if (age < 0 || age > 150) {
            std::cout << "age shu ru you  wu" << std::endl;
            return;
        }
        m_age = age;
        
    }
    void setName(string name) {
        m_name = name;
    }
    void setId(int id) {
        cardId = id;
    }
};


int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    // 实例化 通过类创建对象
    Circle c1;
    //属性赋值
    c1.m_r = 10;
    std::cout << "周长=" << c1.caculate() << std::endl;
    Person person;
    person.setName("李斯");
    person.setId(411323);
    person.personInfo();
    std::cout << person.getName() << "cardID =" << person.getCardId() << std::endl;

    return 0;
}

权限

public: 公共权限：类内类外都可访问

protected  保护权限：类内可以访问 类外不可访问 子类可访问父类保护属性

private 私有权限：类内可以访问 类外不可以访问 子类不能访问父类私有属性

struct 和 class的区别

struct默认权限为公共

class默认权限为私有

demo

#include <iostream>
#include "mathutil.hpp"
#include <string>
using namespace std;
class  Cube{
private:
    double m_width;
    double m_height;
    double m_length;
public:
    void setHeight(double height) {
        m_height = height;
    }
    void setWidth(double width) {
        m_width = width;
    }
    void setLength(double length){
        m_length = length;
    }
    double getWidth() {
        return m_width;
    }
    double getHeight() {
        return m_height;
    }
    double getLength() {
        return m_length;
    }
    
    double getarea() {
        return 2 * m_height * m_width + 2 * m_length * m_height + 2 * m_length * m_width;
    }
    double getcubeaV() {
        return m_width * m_height * m_length;
    }
    bool isSamplecube(Cube &c) {
        if (getWidth() == c.getWidth() && getHeight() == c.getHeight() && getLength() == c.getLength()) {
            return  true;
        }
        return false;
    }

};

bool isSampleCube(Cube &c1, Cube &c2) {
    if (c1.getWidth() == c2.getWidth() && c1.getHeight() == c2.getHeight() && c1.getLength() == c2.getLength()) {
        return  true;
    }
    return false;
}

int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    Cube cube;
    cube.setWidth(10.0);
    cube.setHeight(13.0);
    cube.setLength(23.0);
    
    std::cout << "面积=" << cube.getarea() << "\t 体积=" << cube.getcubeaV() << std::endl;
    
    Cube cube2;
    cube2.setWidth(10.0);
    cube2.setHeight(13.0);
    cube2.setLength(23.0);
   
    if (isSampleCube(cube, cube2)) {
        std::cout  << "cube == cube2" << std::endl;
    } else {
        std::cout  << "cube != cube2" << std::endl;
    }
    
    Cube cube3;
    cube3.setWidth(11.0);
    cube3.setHeight(16.0);
    cube3.setLength(28.0);
    if (cube2.isSamplecube(cube3)) {
        std::cout  << "cube2 == cube3" << std::endl;
    } else {
        std::cout  << "cube3 != cube2" << std::endl;
    }

    
    return 0;
}

  类内有其他类作为成员变量

   

#include <iostream>
#include "mathutil.hpp"
#include <string>
using namespace std;
class Point {
private:
    double m_x;
    double m_y;
public:
    void setX(double x) {
        m_x = x;
    }
    void setY(double y) {
        m_y = y;
    }
    double getX() {
        return m_x;
    }
    double getY() {
        return m_y;
    }
};
class Circle1 {
private:
    double m_r;
    Point  m_point;
    
public:
    void setR(double r) {
        m_r = r;
    }
    void setPoint(Point point) {
        m_point = point;
    }
    double getR() {
        return m_r;
    }
    
    Point getPoint() {
        return m_point;
    }
};
void isInCircle(Circle1 &circle, Point &point) {
    double distance = (circle.getPoint().getX() - point.getX()) *  (circle.getPoint().getX() - point.getX()) + (circle.getPoint().getY() - point.getY()) * (circle.getPoint().getY() - point.getY());
    double mr = circle.getR() * circle.getR();
    
    if (distance == mr) {
        std::cout << "点在圆上" << std::endl;
    } else if (distance < mr) {
        std::cout << "点在圆内" << std::endl;

    } else {
        std::cout << "点在圆外" << std::endl;
    }
}
int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    Point center;
    center.setX(10.0);
    center.setY(0.0);
    Circle1 circle;
    circle.setR(10.0);
    circle.setPoint(center);
    
    
    Point point;
    point.setX(-1.0);
    point.setY(0.0);
    
    
    isInCircle(circle, point);
    return 0;
}

构造函数析构函数

构造函数初始化类

析构函数销毁类资源

对象的初始化和清理工作是由编译器强制要求我们做的 因此我们如果不提供构造函数和析构函数编译器会提供 编译器提供的构造和析构函数是空实现

构造函数： 主要用于创建对象时为对象的成员属性赋值 构造函数由编译器自动调用无需手动调用

析构函数： 主要作用于对象销毁前系统自动调用 执行一些清理工作。

构造函数语法：

类名(){}

1.构造函数没有返回值也不用写void

2.函数名称与类名相同

3.构造函数可以有参数 因此可以重载

4.程序在调用对象的时候会自动调用构造函数 无需手动调用 并且只调用一次。

析构函数语法

1.析构函数没有返回值也不用写void

2.函数名称与类名相同在类名前面加上～

3.析构函数有没有参数 因此不可以重载

4.程序对象销毁前会自动调用析构函数 无需手动调用 并且只会调用一次。

.h文件

#ifndef People_hpp
#define People_hpp

#include <stdio.h>
class People {
public:
    People();
    ~People();
    
};


#endif /* People_hpp */

.cpp文件

#include "People.hpp"
#include <iostream>
People:: People() {
    std::cout << "people 构造函数调用了" << std::endl;
}

People:: ~People() {
    std::cout << "people 析构函数调用了" << std::endl;

}

调用

#include <iostream>
#include "People.hpp"
using namespace std;
int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    People people;
    People p = People();
    return 0;
}

构造函数的分类和调用

按参数分类： 有参构造函数和无参构造函数

按类型分类：普通构造函数和拷贝构造函数

调用方式

1.括号调用

2.显式调用

3.隐式转换法

#ifndef People_hpp
#define People_hpp

#include <stdio.h>
class People {
    int m_age;
public:
    // 有参构造
    People(int age);
    //无参构造
    People();
    //拷贝构造
    People(const People  &p);
    ~People();
    
};


#endif /* People_hpp */

#include "People.hpp"
#include <iostream>
//无参构造 或者默认构造函数
People:: People() {
    std::cout << "people 构造函数调用了。无参构造 或者默认构造函数" << std::endl;
}

People:: ~People() {
    std::cout << "people 析构函数调用了" << std::endl;

}
 
// 有参构造
People:: People(int age) {
    m_age = age;
    std::cout << "people 构造函数调用了。  有参构造" << std::endl;
}

//拷贝构造
People:: People(const People &p) {
    m_age = p.m_age;
    std::cout << "people 构造函数调用了。 拷贝构造" << std::endl;

}

#include <iostream>
#include "People.hpp"
using namespace std;
int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    // 默认构造函数调用
    // 括号调用法
    People p1; // 默认构造函数 注意调用的时候不需要使用小括号 否则编译器会把它当成函数声明People p()
    People p2(25);
    People p3(p2);
    
    //显式法
    People p4 = People(10); // 有参构造
    People p5 = People(p4); // 拷贝构造
    
    //People(22); // 匿名对象 当前行执行结束后系统会立即回收其内存
    // 不要用拷贝对象初始化一个匿名构造函数 编译器会认为是重定义  People(p5)
    
    //隐式转换
    People p6 = 10; //相当于 People p6 = People(10); 有参构造
    People p7 = p6; // 拷贝构造
    return 0;
}
拷贝构造的使用场景

1.使用已经创建完成的对象创建一个新对象

    People p4 = People(10); // 有参构造
    People p5 = People(p4); // 拷贝构造

2.值传递的方式给函数参数传值. （调用函数传值的时候 实参给形参赋值的时候）

#include <iostream>
#include "People.hpp"
using namespace std;
void peopleInfo(People p) {
    std::cout << "peopleInfo!\n" << std::endl;

}
int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    People p;
    peopleInfo(p);
    return 0;
}








Hello, World!
people 构造函数调用了。无参构造 或者默认构造函数
people 构造函数调用了。 拷贝构造
peopleInfo!

people 析构函数调用了
people 析构函数调用了
Program ended with exit code: 0

3.值返回局部对象

#include <iostream>
#include "mathutil.hpp"
#include <string>
#include "People.hpp"
using namespace std;

People createPeople() {
    People p;
    std::cout <<  &p << std::endl;
    return p;
}
void test22() {
    People p1 = createPeople();
    std::cout <<  &p1 << std::endl;

}
int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    test22();
    return 0;
}










Hello, World!
people 构造函数调用了。无参构造 或者默认构造函数
0x7ff7bfeff238
0x7ff7bfeff238
people 析构函数调用了
sh: pause: command not found
Program ended with exit code: 0

    我在xcode上没有试出来  可能不同编译器 处理的不同吧

构造函数调用规则

默认情况下cpp给一个类提供三个函数

1.默认构造函数 函数体为空

2.析构函数 函数体为空

3.默认拷贝构造函数 对属性进行值拷贝

规则

如果自定义了有参构造函数 c++不再提供默认构造函数 但是会提供默认拷贝构造函数

如果自定义了拷贝构造函数 c++不再提供其他构造函数。

深浅拷贝

 使用编译器生层的拷贝构造函数 浅拷贝

 这样在析构释放堆区内存的时候就会crash

#ifndef Phone_hpp
#define Phone_hpp

#include <stdio.h>
class Phone {
private:
    double m_width;
    double* m_height;
public:
    Phone(double width,double height);
    ~Phone();
};
#endif /* Phone_hpp */

#include "Phone.hpp"
#include <iostream>

Phone::Phone(double width,double height) {
    m_width = width;
    m_height = new double(height);
    std::cout << "Phone 构造函数调用了。  有参构造" << std::endl;

}

Phone::~Phone() {
    // 清理堆区开辟的内存
    if (m_height != NULL) {
        delete m_height;
        m_height = NULL;
    }
    std::cout << "Phone 析构函数调用了" << std::endl;

}

#include <iostream>
#include "Phone.hpp"
using namespace std;
void test23() {
    Phone phone(16,20);
    Phone p(phone);

}

int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    
    test23();
    std::cout << "end!\n";

    return 0;
}










Hello, World!
Phone 构造函数调用了。  有参构造
Phone 析构函数调用了
cpplearn(5538,0x7ff85f8bc680) malloc: *** error for object 0x600000010030: pointer being freed was not allocated
cpplearn(5538,0x7ff85f8bc680) malloc: *** set a breakpoint in malloc_error_break to debug
(lldb)

深拷贝 解决类中有在堆区开辟内存的 一定要自己实现拷贝构造函数 防止浅拷贝析构 释放堆区内存时候crash

#ifndef Phone_hpp
#define Phone_hpp

#include <stdio.h>
class Phone {
private:
    double m_width;
    double* m_height;
public:
    Phone(double width,double height);
    Phone(const Phone &p);
    ~Phone();
};
#endif /* Phone_hpp */

#include "Phone.hpp"
#include <iostream>

Phone::Phone(double width,double height) {
    m_width = width;
    m_height = new double(height);
    std::cout << "Phone 构造函数调用了。  有参构造" << std::endl;

}
/// 当类中有指针类型的时候 就需要自己实现拷贝构造函数
Phone::Phone(const Phone &p) {
    m_width = p.m_width;
    m_height =  new double(*p.m_height);
    std::cout << "Phone 拷贝构造函数调用了。" << std::endl;
}

Phone::~Phone() {
    // 清理堆区开辟的内存
    if (m_height != NULL) {
        delete m_height;
        m_height = NULL;
    }
    std::cout << "Phone 析构函数调用了" << std::endl;

}

#include <iostream>
#include "Phone.hpp"
using namespace std;
void test23() {
    Phone phone(16,20);
    Phone p(phone);

}

int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    
    test23();
    std::cout << "end!\n";

    return 0;
}









Hello, World!
Phone 构造函数调用了。  有参构造
Phone 拷贝构造函数调用了。
Phone 析构函数调用了
Phone 析构函数调用了
end!
Program ended with exit code: 0

初始化列表

用来初始化属性

构造函数():属性1:（值1）属性2:（值2)...{}

#include <iostream>
#include <string>
using namespace std;
class Car{
private:
    string m_name;
    string m_color;
    double m_version;
public:
    Car(string name, string color, double version): m_name(name), m_color(color), m_version(version) {
        std::cout << "name = " << m_name << "color = " << m_color << "version = " << m_version << std::endl;
    };
    ~Car() {
        std::cout << "~Car()\n";
    }
};




int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    Car car("bmw","black",8.1);
    std::cout << "end!\n";

    return 0;
}

weixin_38432324
关注
  • 10
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 语法详解
04-03
C++语法详解》对C++的语法进行了全面介绍和深入讲解，内容包括：C++整型、字符型、浮点型、声明、定义、typedef、运算符、表达式、左值、选择语句、循环语句、指针、数组、函数和标识符的作用域、类基础、类作用域及...
基础的数据结构 C++语法学习 C++自带类的底层复现.zip
06-25
本资源"基础的数据结构 C++语法学习 C++自带类的底层复现.zip"提供了一套关于C++数据结构和语法的学习资料，主要针对C++自带类的底层实现进行深入探讨。 首先，我们要理解数据结构是什么。数据结构是组织、管理、...
C++的类和对象
Cosmicsea的博客
05-21 5292
C++面向对象的三大特性：封装、继承、多态 C++认为万事万物皆可为对象，对象有其属性和行为 具有相同性质的对象，可以抽象为类 封装 类在设计时，可以把属性和行为放在不同的权限下，加以控制 public：公共权限，类内可访问、类外可访问， protected：保护权限，类内可访问、类外不可访问，儿子可以访问父亲的保护内容 private：私有权限，类内可访问、类外不可访问，儿子不可以访问父亲的私有内容 struct和class的区别在于 struct的默认权限是public cla
C++——类与对象
Krisit的博客
07-12 948
本章主要讲解了类和对象的关系、类的定义与使用以及对象的概念和使用
C++类和对象数组
夏牧子的博客
05-14 4万+
C++类和对象数组 【1】对象数组 1：对象数组的定义：类名 数组名[元素个数] Eg: student asa[10];//有10个元素的学生类对象数组 2：对象数组的访问形式：数组名[下标].成员名； Eg: asa[j].print(); 3:对象数组的初始化：对象数组的初始化通常也是由构造函数来完成的。 Eg: #include”student.h” int main {...
C++类对象的创建方式
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-11 6047
C++类对象的创建方式
C++类的基本语法。
weixin_51692487的博客
01-16 2588
1、由C语言的结构体进入到C++中的类 我们在C语言中当需要定义多个变量的数据集合时，第一时间会想到使用结构体来进行定义，例如我们定义一个学生变量，包含姓名、年龄、性别等信息，代码示例如下: struct Student{ char name[12]; int age; char sex[4]; }; 但是到了C++用，由于C++面向对象的语法特性，给struct关键字进行了升级，不仅仅可以在struct中定义变量，还可以定义函数，也由此可利用struct来定义一个学生类。代码示例如下： struc
C++类和对象的使用之对象指针
low5252的博客
07-04 2万+
类和对象的使用之对象指针 对象指针的一般概念 对象指针：指向类的成员的指针。在C++中，可以说明指向类的数据成员和成员函数的指针。 对象指针遵循一般变量指针的各种规则：类名 *对象指针名； 对象指针名*成员名； 对象指针在使用之前，也一定要先进行初始化，让它指向一个已经声明过的对象，然后再使用。通过对象指针，可以访问到所指向对象的公有成员。 指向对像的指针 在建立对像时，编译系统会为每一个对像分配...
C++语言类和对象介绍和示例
C语言技术网-码农有道
08-05 1848
C++ 类和对象 C语言中结构体（struct）是一种构造类型，可以包含若干成员变量，可以通过结构体来定义结构体变量。 C++中的类（class）可以看成结构体的升级版，类也是一种构造类型，但是进行了一些扩展，类的成员不但可以有变量，还可以有函数，通过类定义出来的变量也有特定的称呼，叫做对象。 示例（book205.cpp） ...
C++类和对象（万字总结）（建议收藏！！！）
IamGreeHand的博客
09-27 9349
文章目录面向过程和面向对象初步认识类的引入类的定义类的两种定义方法1.声明和定义全部放在类体中2. 声明放在.h文件中，类的定义放在.cpp文件中类的访问限定符及封装访问限定符封装类的作用域类的实例化类对象模型如何计算类对象的大小类对象的存储方式this 指针this指针的引出this指针的特性类的6个默认成员函数构造函数构造函数的特性析构函数特性拷贝构造函数特性运算符重载==运算符重载= 运算符重载const修饰成员函数再谈构造函数构造函数体赋值初始化列表注意事项1.每个成员变量在初始化列表中只能出现一次
C++基本语法
HyoJoo-W的博客
10-03 2909
C++ primer学习记录...
Java类和对象 详解（一）
热门推荐
wei_zhi的博客
10-06 18万+
一、面向对象简述面向对象是一种现在最为流行的程序设计方法，几乎现在的所有应用都以面向对象为主了，最早的面向对象的概念实际上是由IBM提出的，在70年代的Smaltalk语言之中进行了应用，后来根据面向对象的设计思路，才形成C++，而由C++产生了Java这门面向对象的编程语言。但是在面向对象设计之前，广泛采用的是面向过程，面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主，实
C++类和对象的思维导图
08-02
内容比较多，都是有关C++中有关类和对象的语法。大家可以根据自己的情况去食用
C++全套学习教程，包括基本语法，面向对象和模版及标准C++部分
08-10
C++全套学习教程，包括基本语法，面向对象和模版及标准C++部分
C++语法学习代码 C++学习资源
07-27
本资源包是针对C++语法的学习资料，旨在帮助初学者和进阶者深入理解并掌握C++的核心概念。 在C++中，语法是编程的基础，它规定了如何组织代码以实现特定的功能。以下是一些关键的C++语法知识点： 1. **基本数据...
18045 前一个和后一个字符
huang1xiao1sheng的博客
08-31 216
编写程序，输入一个数字字符，输出其前一个和后一个的数字字符，如果输入的是0前一个输出 “first”，9后一个则输出“last”，输入的不是数学字符，输出“error” 输入格式 一个字符 输出格式 输出结果 输入样例 0 输出样例 first 1
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1236
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
C++友类匿名对象，运算符重载
最新发布
m0_75109289的博客
09-02 240
【代码】C++友类匿名对象，运算符重载。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 4005
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
C++类与对象详解：指针、引用与高效编程
3. 子对象和堆对象：子对象是类中嵌套的其他对象，而堆对象则是在程序运行时动态分配内存的对象，这与栈上对象不同，需要程序员手动管理内存。 4. 类型转换：正确地将一个类型转换为另一个类型是关键，特别是当涉及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值