C++创建对象时，有哪些内容？

已于 2022-12-18 12:48:00 修改
阅读量464 收藏
点赞数
分类专栏： 小菜鸡的日记本 C++ 文章标签： c++
于 2022-12-13 16:31:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51323520/article/details/128303977
版权

C++创建对象时，有哪些内容？

数据成员

在类的作用域中，数据成员类似全局变量，而成员函数是操作数据成员的函数

成员函数

内联函数

介绍

目的：为了提高运行时的效率
注意：在内联函数体中不要有复杂结构（如循环语句和switch语句）
在类中声明内敛函数的方式：

  • 将函数体放在类的声明中
  • 使用inline关键词
举例
class Point{
public:
	void Init(int initX,int initY){
        X = initX;
        Y = initY;
    }
	int GetX(){return X;}
	int GetY(){return Y;}
private:
	int X,Y;
}

重载函数

介绍：
  • 同⼀个类空间中的同名函数称为重载函数。
  • ⼀个类的成员函数与另⼀个类的成员函数即使同名，也不能够认为是重载。
举例
void SetDate(int y,int m,int d){
    year = y;month = m; day = d;
}
void SetDate(int y,int md){
    year = y;month = day = md;
}

构造函数

介绍
  • C++规定与类同名的成员函数是构造函数;
  • 主要⽤途：构造对象
    • 给对象赋予有意义的初始值.
    • 给数据成员分配内存，然后初始化
特点

1).名字与类名相同.没有返回类型.
2).构造函数可以重载，⽤不同的⽅式创建对象.
3).⼀般由系统⾃动、隐式的调⽤.
4).访问权限⼀般为public。
5).创建对象引⽤和对象指针时，不会调⽤构造函数，也不会调⽤成员函数。

举例
#include <iostream>
using namespace std;
class Circle { 
private: 
	double radius; 
public: 
	//构造函数1	
	Circle() { 
        cout << "Circle::Circle()\n"; 
        radius = 0; 
    } 
	//构造函数2
    Circle(double d) { 
        cout << "Circle::Circle(double)\n"; 
        radius = d; 
    } 
    double Area() {return 3.14 * radius * radius;} 
};
int main(){
    Circle p;
    cout<<p.Area()<<endl;
    Circle c(10);
    cout<<c.Area()<<endl;
}

析构函数

介绍

对象⽣成—>构造（构造函数）
对象撤销—>析构（析构函数）
1).名字是在类名之前加上‘~ ’ ，表示逆构造（就是析构），是构造函数的反函数
2).析构函数没有返回类型，没有参数，只能有⼀个，⽽且不能重载
3).析构函数以构造函数相反的顺序被调⽤
4).⽤new运算符创建对象时，会⾃动调⽤相应的构造函数，在⽤delete运算符释放时，⾃动调⽤析构函数

举例
#include <iostream>
using namespace std;
class Point{
private:
    int x, y;
public:
    Point() {
        cout<<"Point()"<<endl;
        x = y = 0;
        std::cout << x << "," << y << std::endl;
    }
    Point(int a) {
        cout<<"Point(int a)"<<endl;
        x = y = a;
        std::cout << x << "," << y << std::endl;
    }
    Point(int a, int b) {cout<<"Point(int a, int b)"<<endl; x = a; y = b;
    	std::cout << x << "," << y << std::endl;
    }
    ~Point() {
        cout<<"~Point()";std::cout << x << "," << y << std::endl;
    }
};

int main(){
    Point p;
    Point q(2);
    Point r(3, 4);
    p = Point(1, 2);
    cout <<"leaving main()"<<endl;
}

转换构造函数

介绍

1.对于系统的预定义基本类型数据，C++提供了两种类型转换⽅式：隐式类型转换和显式类型转换。

int a=sum;
double b=5.55;
sum=a+b;
//-------(1)
std::cout<<"隐式转换：a+b="<<sum<<std::endl;
sum=(int)(a+b);
//-------(2)
sum=int(a+b);
//-------(3)
cout<<"显式转换：a+b="<<sum<<std::endl

2.对于⽤户⾃定义的类类型，C++中提供了2种⽅法实现它们和其他数据类型之间的转换：

  • (1)通过转换构造函数进⾏类型转换；把其他类型转化为⾃身类的对象
  • (2)通过类型转换函数进⾏类型转换。把⾃身类的对象转换为其他类型
转换构造函数（将其他类型转化为⾃身类的对象）

也是构造函数的一种，具有类型转换的作用。

#include <iostream>
class Complex //复数类
{
private://私有
    double real;//实数
    double imag;//虚数
public:
    Complex(double real,double imag){
        this->real=real;
        this->imag=imag;
        }
    Complex(double d=0.0)//转换构造函数{
        real=d;//实数取double类型的值
        imag=0;//虚数取0
        cout<<"转换构造函数"<<std::endl;
        }
    void showComplex();
};

void Complex::showComplex(){
    cout<<real;
    if(imag>0)
    cout<<"+";
    if(imag!=0)
    cout<<imag<<"i"<<std::endl;
}

int main(){
    Complex sum;
    sum = 5.5;
    //5.5调⽤Complex(5.5)⽣成临时对象,它的复数是5.5+0i
    sum.showComplex();//输出运算结果
    return 0;
}

29行 sum = 5.5;

就是将Double类型转换为Complex类型

类型转换函数（operator关键字）

介绍

1.对于系统的预定义基本类型数据，C++提供了两种类型转换⽅式：隐式类型转换和显式类型转换。

int a=sum;
double b=5.55;
sum=a+b;
//-------(1)
std::cout<<"隐式转换：a+b="<<sum<<std::endl;
sum=(int)(a+b);
//-------(2)
sum=int(a+b);
//-------(3)
cout<<"显式转换：a+b="<<sum<<std::endl

2.对于⽤户⾃定义的类类型，C++中提供了2种⽅法实现它们和其他数据类型之间的转换：

  • (1)通过转换构造函数进⾏类型转换；把其他类型转化为⾃身类的对象
  • (2)通过类型转换函数进⾏类型转换。把⾃身类的对象转换为其他类型
类型转换函数（将⾃身类的对象转化为其他类型）

转换构造函数可以把其他类型转化为⾃身类的对象，但是却不能把⾃身类的对象转换为其他类型。⽐如：不能将Complex类(复数类)的对象转换成double类型数据。于是在C++中就⽤类型转换函数实现把⾃身类的对象转换为其他类型。

#include <iostream>
class Complex //复数类
{
private://私有
    double real;//实数
    double imag;//虚数
public:
    Complex(double real,double imag){
        this->real=real;
        this->imag=imag;
    }
    Complex(double d=0.0)//转换构造函数
    {
        real=d;//实数取double类型的值
        imag=0;//虚数取0
        std::cout<<"转换构造函数"<<std::endl;
    }
    operator double()//类型转换函数
    {
        return real;
    };
    void showComplex();
};

![image.png](https://img-blog.csdnimg.cn/img_convert/ef02024cb0be1ffe8ecb27b7a96761da.png#averageHue=#292f38&clientId=u6ec38efa-a38c-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=83&id=u6e214eed&margin=[object Object]&name=image.png&originHeight=104&originWidth=311&originalType=binary&ratio=1&rotation=0&showTitle=false&size=6897&status=done&style=none&taskId=ufb35155f-8566-42db-94f2-2e5cf07290e&title=&width=248.8)
重要的标志是operator

复制构造函数

介绍
  • 实现相同对象之间的相互复制[copy constructor]
  • 注意如果不是相同对象，其实调用是转换构造函数（将其他类型转化为⾃身类的对象）
  • 每个类都必须有⼀个复制构造函数。如果没有,则系统会⾃动提供⼀个
  • “复制”的好处：得到对象的副本
    • Student s(2008001, “Tom” , 90);
    • Student t(s);
特点

关键点：所带参数
特征：

  • 只有⼀个参数；
  • 必须是对象引⽤；
  • 通常声明为常量引⽤（&符号）
两种形式：= 和 （）
struct S{int x;double y;};
S a = {1, 2};
//实现形式1
S b = a;
assert(b.x == 1&&b.y == 2);
//实现形式2
S c(b);
assert(c.x == 1&&c.y == 2);
用途
  • 同类对象相互初始化
#include <iostream>
#include <cstring>
using namespace std;
class Square{
private:
    double length, area;
public:
    Square(double d = 0){
        length = d;
        area = length * length;
    }
    Square(const Square& s){
        cout<<"Square(const Square& s)"<<endl;
        length = s.length;
        area = s.area;
        std::cout << "length:\t" << length << std::endl;
	}
    double GetArea() {
        return area;
    }
};
int main(){
    Square s(10);
    Square t = s; cout<<t.GetArea();
    Square r(t); cout<<r.GetArea();
}
  • 传值调用时实参传给形参
#include <iostream>
#include <cstring>
using namespace std;
class CInt{
private:
	int n;
public:
    CInt(int m = 0) {
        cout<<"CInt(int m = 0)"<<endl;
        n = m;
        cout<<n<<endl;
    }
    CInt(const CInt& c) {
        cout<<"CInt(const CInt& c) "<<endl;
        n = c.n;
        cout<<n<<endl;
    }
    ~CInt() {
        cout<<"~CInt()"<<endl;
    	cout<<n<<endl;
    }
    int GetN() const { 
        return n; 
    }
};

int sum(CInt c, int n){
    cout << "entering sum..." << endl;
    return c.GetN() + n;
};

int main(){
    int n = 2;
    CInt x(1);
    cout<<sum(x, n)<<endl;
    cout << "leaving main..." << endl;
}

/*int sum(CInt &c, int n){
    cout << "entering sum..." << endl;
    return c.GetN() + n;
}
int main(){
    int n = 2;
    CInt x(1);
    cout<<sum(x, n)<<endl;
    cout << "leaving main..." << endl;
}*/
  • 返回值返回对象
#include <iostream>
#include <cstring>
using namespace std;
class CInt{
private:
	int n;
public:
    CInt(int m = 0) {
        cout<<"CInt(int m = 0)"<<endl;
        n = m;
        cout<<n<<endl;
    }
    CInt(const CInt& c) {
        cout<<"CInt(const CInt& c) "<<endl;
        n = c.n;
        cout<<n<<endl;
    }
    ~CInt() {
        cout<<"~CInt()"<<endl;
    	cout<<n<<endl;
	}
}
CInt MakeCInt(int n){
    cout<<"inMakeCInt"<<endl;
    CInt temp(n);//这里是普通的构造函数
    return temp;//这里才调用复制构造函数
}
int main(){
	MakeCInt(1);
    cout<<"Leavding main..."<<endl;
}
/*
CInt& MakeCInt(int n){
	cout << "in MakeCInt..." << endl;
    CInt temp(n);
    return temp;
}
int main(){
	MakeCInt(1);
}
*/
//加&与不加&的区别是：
//return由CInt z = temp;变为CInt &z = temp;
复制构造函数举例
#include <iostream>
#include <cstring>
using namespace std;
class Song
{
private:
	char singer[80]; char title[80]; double size;
public:
    Song(char* sg = "", char* tl = "", double s = 0){ 
        strcpy(singer, sg); strcpy(title, tl); size = s; 
    }
	//复制构造函数（同类型之间）
    Song(const Song& s){
        cout<<"Song(const Song& s)"<<endl;
    	strcpy(singer, s.singer); strcpy(title, s.title);
    	size = s.size;
    	static int copied_times = 0; ++copied_times;
    	cout<<copied_times<<endl;
	}
};

int main()
{
    Song original("Mariah Carey","Hero",4705.610);
    Song a(original);
    Song b(a);
    Song c(original);
}

赋值运算符函数

介绍：
  • 在对象之间相互赋值。
  • 系统⾃动给每个类提供⼀个赋值运算符函数，但是适用于基本类型，如果自定义类的话，需要重新修改才能达到最佳效果。
  • 赋值的好处：得到样本的数据
定义
T& operator = (const T& rhs){
	//依次复制数据成员
    //...
    return *this;
}

注意：赋值运算符函数，没有返回值也能完成赋值，但是不可以进行a=b=c;的操作。如果有return*this;那么“a=b=c”中“b=c”会返回b的值，即继续完成a=（b=c）。

赋值运算符函数举例
#include <iostream>
#include <cstring>
using namespace std;
class Word{
private:
	char buffer[128]; int length;
public:
    Word(char* s = "", int n = 0);
    Word(const Word& w);
    ~Word() {};
    Word& operator = (const Word& rhs);
    void Print() {
        std::cout << length << ": " << buffer << "\n";
    }
};
Word::Word(char* s, int n){
    length = std::min<int>(n, strlen(buffer));
    strncpy(buffer, s, length);
    buffer[length] = '\0';
}
Word::Word(const Word& w){
    cout<<"Word::Word(const Word& w)"<<endl;
    strcpy(buffer, w.buffer);
    length = w.length;
    Print();
}
Word& Word::operator = (const Word& rhs){
    cout<<"Word& Word::operator = (const Word& rhs)"<<endl;
    strcpy(buffer, rhs.buffer);
    length = rhs.length;
    Print();
    return *this;
}
int main(){
    Word a("Hello", 5);
    Word b(a);
    Word c = a;
    Word d;
    d = a;
/*
	注意word c = a；和word d；d = a；是不一样的。前者调用复制构造函数，后者调用赋值运算符函数
*/
}
江乌好困
关注
专栏目录
C/C++程序员为什么要了解汇编？了解汇编有哪些好处？如何学习汇编？
dvlinker的技术专栏
10-09 4万+
本文详细讲解了C++程序员为什么要了解汇编，了解汇编都有哪些具体的好处，如何学习汇编，以及如何看懂汇编代码上下文等，希望能给大家提供一定的借鉴或参考。
为什么要学习使用C++常用软件分析工具？学会这些工具都有哪些好处？
最新发布
dvlinker的技术专栏
06-14 1万+
本文详细讲述为什么要学习使用C++软件分析工具，以及学会这些工具的使用都有哪些好处。
C++ 类对象的构造过程
ciaoniao1715的博客
03-09 651
在C++中构造一个类对象的时候， 编译器会首先为该类对象分配存储空间然后调用该类的构造函数。下面我们看一个例子：#include class BaseA { public: BaseA() { printf("Call BaseA NoParamConstructor!\n"); } BaseA(const BaseA& baseA) { printf("Call Base
C++【对象模型】| 【07】构造、析构、拷贝做了哪些事？
weixin_45926547的博客
05-07 437
文章目录纯虚函数无继承下的对象构造抽象数据类型为继承做准备继承体系下的对象构造虚拟继承vptr初始化语意学 纯虚函数 当一个类如以下设计，有哪些地方需要改进 class Abstract_base { public: virtual ~Abstract_base() = 0; virtual void interface() const = 0; virtual const char* mumble() const { return _mumble; } protected:
（1） C++ 类的构造都会做哪些事?
weixin_30502965的博客
05-04 114
struct Point { int x ; int y ; }; class CBase { public: CBase(void); ~CBase(void); public: Point point ; public: virtual void Draw(); virtual void ...
C++（day 10）构造对象应注意哪些顺序问题
无
05-03 505
目录前言1. 局部和静态对象，以声明的顺序构造2. 静态对象只被构造一次3. 所有全局对象在主函数mian之前被构造4. 全局对象构造时无特殊顺序5. 成员以其在类中声明的顺序构造 前言 1. 局部和静态对象，以声明的顺序构造 局部和静态对象是指块作用域和文件作用域的对象。它们声明的顺序与它们在程序中出现的顺序是一致的。 先回顾一下全局对象和局部对象的相关概念： 局部对象是指只在局部使用，比如在...
C++对象的构造
Oshyn —— 乐而学，学而乐
05-31 1178
C++中通过用户自定义类建立对象时，需要调用构造函数，这里包含默认构造函数、复制构造函数和自定义构造函数。其中自定义构造函数，按照函数重载机制进行匹配调用，与普通重载函数调用类似。因此，这里讨论的是默认构造函数和复制构造函数，因为这两种构造函数如果用户不显式定义，会在特定情况下被编译器合成出来。编译器合成的规则并不明显，C++标准做的说明只是“在需要的时候合成”。默认构造函数（default con
Java和C++通过new创建的对象有何区别？
08-28
Java 和 C++ 都是流行的面向对象编程语言，但它们在创建对象时有着显著的差异，尤其是在内存管理和对象生命周期方面。下面我们将详细探讨这两种语言通过 `new` 关键字创建对象的区别。 首先，让我们从 Java 开始。...
Java创建对象与C++创建对象的比较
12-22
　1、C++创建对象方式 　在C++中我们可以采用如下两种方式来创建对象， 1 Dog dog;//Dog为类名 2 Dog *p = new Dog(); 　这两种方式在C++中都能完成对象的创建，但是在内存中的处理却完全不同。 　对于...
c++ rtti 根据类名创建对象
08-08
实现c++根据类名创建c++ 对象，一个文件简单明了，，，，，
C++对象构造过程
最爱吹吹风
04-28 1万+
一个C++对象固定的几个部分: 构造、析构、虚表指针(如果有虚函数)、类型信息 先说说一个C++对象整个的生成过程 构造父类 构造自身成员变量 构造自身 一个对象在构造之前会先分配内存，然后调用构造函数，编译器在构造函数之前又插入了为虚指针赋值的操作，将class对应的虚表指针交给对象的vptr，然后继续执行构造函数中的代码。 ...
深入理解C++对象的构造过程(笔记)
十一月zz的博客
08-24 817
如果我们要通过某个class_A来instance一个对象object_A，通常要include class_A所在的头文件(class_A.h)。我的问题是，include class_A.h的作用是什么？ 答： 很自然的，也是很表面的一个问题是，如果你不include class_A.h，编译会报错，会显示class_A是一个undefined type. 深层次的理解是：include class_A是给编译器提供该class的原型，编译器根据这个原型来为object_A来分配空间。也就是分配.
21 C++ - 对象的构造和析构
阿甘兄
10-08 403
1. 初始化和清理 我们大家在购买一台电脑或者手机，或者其他的产品，这些产品都有一个初始设置，也就是这些产品对被创建的时候会有一个基础属性值。那么随着我们使用手机和电脑的时间越来越久，那么电脑和手机会慢慢被我们手动创建很多文件数据，某一天我们不用手机或电脑了，那么我们应该将电脑或手机中我们增加的数据删除掉，保护自己的信息数据。 从这样的过程中，我们体会一下，所有的事物在起初的时候都应该有个初始状态...
C++对象构造与析构全流程
Innocent_code的专栏
02-27 676
对象构造流程 1. 首先，如果有virtual base class constructors,虚基类的构造函数必须被调用，从左往右，从深往浅： -&gt;如果有virtual base class constructor位于成员初值列，有任何显示指定的参数都应该传递过去；若没有位于初值列，而virtual base class含有一个默认构造函数，也应该调用。 -&gt;class中的...
C++的对象构造顺序
　
03-25 3618
最近要开始准备笔面试了，找几份笔试题，觉得挺吃惊的，本来觉得基础看的差不多了，这下又弄的我晕乎乎的。 笔面试出现的那些题目有的考的真细啊， 一些妖娆的写法要问运行结果，这些东西书上提的太少，若不是自己尝试过一时间还怎么不知道怎么下手了。 我是觉得没必要没完没了的浪费时间去琢磨这些，C++本来不好掌握，如果精力多的话，花时间来规范书写、放弃使用糟糕方法更好，而不是一个个去琢磨。 总之，人家非得
C++对象的构造顺序解析
GoingJack博客
06-18 347
#include <iostream> using namespace std; class Test { public: Test(int data = 10) :ma(data) { cout << "Test(int)" << endl; } ~Test() { cout << "~Test(int)" << e...
C++构造函数种类，对象的生命历程
sunSHINEEzy的博客
09-28 851
构造函数之默认构造函数（调用的构造函数不用传递参数） 两种实例化方式都是默认构造函数 构造函数之初始化列表 红字部分即为初始化列表：一个引号，多个参数用逗号隔开，赋值用() 初始化列表特性： 其先于构造函数执行其只能用于构造函数其可以同时初始化多个数据成员 【注意】初始化列表的功用：对于类中的静态常量，不能用构造函数来初始化，必须使用初始
【C++基础入门】14.C++中对象的构造
老胡的博客
03-06 1352
一、对象的构造（上） 1.1 对象的初始值 问题：对象中成员变量的初始值是多少? 下面的类定义中成员变量 i 和 j 的初始值为多少? 下面看一段成员变量初始值的代码： #include<stdio.h> class Test { private: int i; int j; public: int getI() {return i;} int getJ() {return j;} }; .
创建对象及其修改
前端小白
02-09 222
对象 什么是对象 对象是一种复合的数据类型，在对象中可以保存各种不同类型的数据 对象是属性和方法的集合 JavaScript 对象是变量的容器 对象的分类 （1）内置对象 ES标准中定义的对象，任何ES都可以使用 常用内置对象：math、string、number、function等 （2）宿主对象 由js运行环境提供的对象，目前主要指浏览器提供的对象 常用宿主对象：BOM、DOM （3）自定义的对象 由开发人员自己定义的对象 创建一个对象 （1）字面量方式 形式： var obj={
C++创建对象有几种方式
02-06
在 C 语言中，可以使用以下几种方式创建对象： 1. 通过调用 malloc 或 calloc 函数动态分配内存来创建对象。 2. 在栈上定义对象，如：int x; 3. 在全局或静态存储区中定义对象，如：int x = 0; 4. 使用宏定义或内联函数来创建对象。 5. 在 C++ 中可以使用 new 运算符来创建动态对象。 注意，在 C 语言中，对象并不是指类的实例，而是指任何类型的变量。因此，在 C 语言中，数组、指针、结构体、联合体等都可以被看作是对象。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值