【C++】不止于基础：再探构造函数、类型转换与 static 成员

原创 已于 2026-03-25 22:34:53 修改 · 565 阅读 · 15 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#c++ #开发语言 #github #算法 #后端
#c语言 #数据结构
于 2026-03-14 19:04:37 首次发布

在这里插入图片描述

🔭 个人主页：散峰而望

《C语言：从基础到进阶》《编程工具的下载和使用》《C语言刷题》
《C++》《算法竞赛从入门到获奖》《人工智能》《AI Agent》

愿为出海月，不做归山云

🎬博主简介

在这里插入图片描述

请添加图片描述

【C++】不止于基础：再探构造函数、类型转换与 static 成员

前言

C++ 中，构造函数、类型转换和 static 成员是构建高效、可维护代码的核心机制。深入理解这些概念不仅能提升代码质量，还能解锁更灵活的设计模式与编程技巧。

构造函数不仅是对象的初始化工具，通过重载、委托和移动语义，它能显著优化资源管理。类型转换提供了隐式与显式的类型适配能力，合理使用可以增强代码的表达力，同时避免潜在风险。static 成员则跨越对象实例，实现数据共享与类级别操作，是设计工具类和全局状态管理的利器。

本文将从基础出发，逐步剖析这些特性的高级用法，帮助开发者掌握更精妙的 C++ 实践技巧。

1. 再探构造函数

  1. 之前我们实现构造函数时，初始化成员变量主要使用函数体内赋值，构造函数初始化还有一种方式，就是初始化列表，初始化列表的使用方式是以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
#include<iostream>
using namespace std;

class Date
{
public:
    Date(int year, int month, int day)
        :_year(year)//参数year赋给_year
        , _month(month)//参数month赋给_month
        , _day(day)//参数day赋给_day
    { }
private:
    int _year;
    int _month;
    int _day;
   };
  1. 每个成员变量在初始化列表中只能出现一次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地方。
#include<iostream>
using namespace std;

class Date
{
public:
    Date(int year, int month, int day)
        //成员变量定义
        :_year(year)//参数year赋给_year
        , _month(month)//参数month赋给_month
        , _day(day)//参数day赋给_day
    { }
private:
    //声明
    int _year;
    int _month;
    int _day;
   };

int main()
{
    //对象定义
    Date d1(2026, 3, 14);
}
  1. 引用成员变量，const 成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进行初始化，否则会编译报错。
#include<iostream>
using namespace std;

class Date
{
public:
    Date(int& x, int year = 1, int month = 1, int day = 1)
        :_year(year)
        , _month(month)
        , _day(day)
        , _ref(x)
        , _n(1)
    {
        // error C2530 : “Date::_ref” : 必须初始化引用 
        // error C2789 : “Date::_n” : 必须初始化常量限定类型的对象 
    }
    
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
    //必须在初始化列表初始化
    int& _ref;          // 引用 
    const int _n; // const 
};

int main()
{
    int i = 0;
    int x = 0;
    Date d1(i);
    Date d2(x, 2026, 3, 14);
    d1.Print();
    d2.Print();
    return 0;
}
  1. 一般情况下，不用传参就可以调用的称为默认构造，如果有默认构造的类类型变量，则不需要初始化列表初始化。
#include<iostream>
using namespace std;

class Time
{
public:
    Time(int hour = 0)//全缺省，不用传参
        :_hour(hour)
    {
        cout << "Time()" << endl;
    }
private:
    int _hour;
};

class Date
{
public:
    Date(int& x, int year = 1, int month = 1, int day = 1)
        :_year(year)
        , _month(month)
        , _day(day)
        //, _t(12)
        , _ref(x)
        , _n(1)
    {   }
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
    Time _t;          // 有默认构造 
    int& _ref;          // 引用 
    const int _n; // const 
};
int main()
{
    int i = 0;
    int x = 0;
    Date d1(i);
    Date d2(x, 2026, 3, 14);
    d1.Print();
    d2.Print();
    return 0;
}

但是没有默认构造的类类型变量，就需要初始化列表初始化。

在这里插入图片描述

class Time
{
public:
    Time(int hour)
        :_hour(hour)
    {
        cout << "Time()" << endl;
    }
private:
    int _hour;
};
class Date
{
public:
    Date(int& x, int year = 1, int month = 1, int day = 1)
        :_year(year)
        , _month(month)
        , _day(day)
        , _t(12)//初始化列表初始化
        , _ref(x)
        , _n(1)
    {
        // error C2512: “Time”: 没有合适的默认构造函数可用 
        // error C2530 : “Date::_ref” : 必须初始化引用 
        // error C2789 : “Date::_n” : 必须初始化常量限定类型的对象 
    }
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
    Time _t;          // 没有默认构造 
    int& _ref;          // 引用 
    const int _n; // const 
};
int main()
{
    int i = 0;
    int x = 0;
    Date d1(i);
    Date d2(x, 2026, 3, 14);
    d1.Print();
    d2.Print();
    return 0;
}

初始化列表和函数体可以混着用，相互搭配，相辅相成。

#include<iostream>
using namespace std;

class Time
{
public:
    Time(int hour)
        :_hour(hour)
    {
        cout << "Time()" << endl;
    }
private:
    int _hour;
};
class Date
{
public:
    Date(int& x, int year = 1, int month = 1, int day = 1)
        :_year(year)
        , _month(month)
        , _day(day)
        , _t(12)
        , _ref(x)
        , _n(1)
        ,_ptr((int*)malloc(10))
    {
        if (_ptr == nullptr)
        {
            perror("malloc fail");
        }
        else
        {
            memset(_ptr, 0, 10);
        }
        // error C2512: “Time”: 没有合适的默认构造函数可用 
        // error C2530 : “Date::_ref” : 必须初始化引用 
        // error C2789 : “Date::_n” : 必须初始化常量限定类型的对象 
    }
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
    Time _t;          // 没有默认构造 
    int& _ref;          // 引用 
    const int _n; // const 
    int* _ptr;
};

成员变量不一定都要定义，有的也可以不定义。当然，引用成员变量，const 成员变量，没有默认构造的类类型变量除外。不过没有被定义的成员变量输出的时候会是随机值，是不确定的。

class Date
{
public:
    Date(int year, int month, int day)
        //成员变量定义
        :_year(year)//参数year赋给_year
        , _month(month)//参数month赋给_month
    { }
private:
    //声明
    int _year;
    int _month;
    int _day;
   };

在这里插入图片描述

  1. C++11 支持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。
#include<iostream>
using namespace std;

class Date
{
public:
    Date(int year, int month, int day)
        :_year(year)
        , _month(month)
        , _day(day)
    {    }

    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:
    int _year = 1;
    int _month = 1;
    int _day =1;
};

int main()
{
    Date d1(2026, 3, 14);
    d1.Print();
}

在这里插入图片描述

除了普通的内置类型可以在声明处给缺省值，类类型也可以给缺省值。同时还能给表达式。

Time _t = 1;          
int* _ptr = (int*)malloc(10);

#include<iostream>
using namespace std;

class Time
{
public:
    Time(int hour)
        :_hour(hour)
    {
        cout << "Time()" << endl;
    }
private:
    int _hour;
};

class Date
{
public:
    Date()
        :_month(2)
    {
        cout << "Date()" << endl;
    }
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    // 注意这里不是初始化，这里给的是缺省值，这个缺省值是给初始化列表的 
    // 如果初始化列表没有显示初始化，默认就会用这个缺省值初始化 
    int _year = 1;
    int _month = 1;
    int _day;
    Time _t = 1;
    const int _n = 1;
    int* _ptr = (int*)malloc(12);
};

int main()
{
    Date d1;
    d1.Print();
    return 0;
}

  1. 尽量使用初始化列表初始化，因为那些你不在初始化列表初始化的成员也会走初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会用这个缺省值初始化。如果你没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++ 并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。

  2. 初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。建议声明顺序和初始化列表顺序保持一致。

在这里插入图片描述

  1. 函数定义的形参给的缺省值和声明给缺省值的区别：函数定义中的缺省值是否有用在于是否传参，如果传参则函数定义的缺省值便失效了。若此时声明中没有初始化，会传随机值。
class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
        :_year(year)
        , _month(month)
        , _day(day)
    {    }

    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:
    int _year = 1;
    int _month = 1;
    int _day =1;
};

初始化列表总结：

  • 无论是否显示写初始化列表，每个构造函数都有初始化列表；
  • 无论是否在初始化列表显示初始化成员变量，每个成员变量都要走初始化列表初始化；

在这里插入图片描述

接下来个小测试检验一下。

测试：

#include<iostream>
using namespace std;

class A
{
public:
    A(int a)
        :_a1(a)
        , _a2(_a1)
    {
    }
    void Print() {
        cout << _a1 << " " << _a2 << endl;
    }
private:
    int _a2 = 2;
    int _a1 = 2;
};

int main()
{
    A aa(1);
    aa.Print();
}

下面程序的运行结果是什么（ ）
A. 输出 1 1
B. 输出 2 2
C. 编译报错
D. 输出 1 随机值
E. 输出 1 2
F. 输出 2 1

答案：C
在这里插入图片描述
在这里插入图片描述

这里讲一个困惑点，可能会有人认为 _a1 不是缺省值为 2 了吗，为什么 _a2 还为随机值：

  1. 先初始化 _a2：使用 _a1 的值，但此时 _a1 尚未初始化（既未用缺省值，也未用列表值），所以 _a2 被未定义的值初始化。
  2. 后初始化 _a1：使用参数 a 的值（1），或者如果没有显式列表，则使用缺省值 2。

所以，即使 _a1 有缺省值 2，它也是在 _a2 初始化之后才被设置的，因此 _a2 无法看到那个缺省值。

2. 类型转换

C++ 支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。

构造函数前面加 explicit 就不再支持隐式类型转换。

类类型的对象之间也可以隐式转换，需要相应的构造函数支持。

#include<iostream>
using namespace std;

class A
{
public:
    // 构造函数explicit就不再支持隐式类型转换 
    // explicit A(int a1)
    A(int a1)
        :_a1(a1)
    {
    }
    //explicit A(int a1, int a2)
    A(int a1, int a2)
        :_a1(a1)
        , _a2(a2)
    {
    }
    void Print()
    {
        cout << _a1 << " " << _a2 << endl;
    }
    int Get() const
    {
        return _a1 + _a2;
    }
private:
    int _a1 = 1;
    int _a2 = 2;
};

class B
{
public:
    B(const A& a)
        :_b(a.Get())
    {
    }
private:
    int _b = 0;
};

int main()
{
    // 1构造一个A的临时对象，再用这个临时对象拷⻉构造aa3 
    // 编译器遇到连续构造+拷⻉构造->优化为直接构造 
    A aa1 = 1;
    aa1.Print();
    const A& aa2 = 1;
    // C++11之后才支持多参数转化 
    A aa3 = { 2,2 };
    // aa3隐式类型转换为b对象 
    // 原理跟上面类似 
    B b = aa3;
    const B& rb = aa3;
    return 0;
}

3. static 成员

用 static 修饰的成员变量，称之为静态成员变量，静态成员变量一定要在类外进行初始化。

静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。

用 static 修饰的成员函数，称之为静态成员函数，静态成员函数没有 this 指针。

静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有 this 指针。

非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。

突破类域就可以访问静态成员，可以通过 类名 :: 静态成员 或者 对象 . 静态成员 来访问静态成员变量和静态成员函数。

静态成员也是类的成员，受 public、protected、private 访问限定符的限制。

静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不走构造函数初始化列表。

#include<iostream>
using namespace std;
class A
{
public:
    A()
    {
        ++_scount;
    }
    A(const A& t)
    {
        ++_scount;
    }
    ~A()
    {
        --_scount;
    }
    static int GetACount()
    {
        return _scount;
    }
private:
    // 类里面声明 
    static int _scount;
};
// 类外面初始化 
int A::_scount = 0;

int main()
{
    cout << A::GetACount() << endl;
    A a1, a2;
    A a3(a1);
    cout << A::GetACount() << endl;
    cout << a1.GetACount() << endl;
    // 编译报错：error C2248: “A::_scount”: 无法访问 private 成员(在“A”类中声明) 
    //cout << A::_scount << endl;
    return 0;
}

测试：

求 1 + 2 + 3 +…+ n

根据题目乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C） 可知循环、递归、等差公式都没法使用。

因为当定义一个对象数组时，会为数组中的每一个元素分别调用其默认构造函数，因此创建 Sum a[n]; 就相当于创建 n 个 Sum 对象，构造 n 次。

class Sum
{
public:
   Sum()
   {
       _ret += _i;
       ++_i;
   }

   static int GetRet()
   {
      return _ret;
   }
private:
    static int _i;
    static int _ret;//记录结果
};

int Sum::_i = 1;
int Sum::_ret = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        Sum a[n];//变长数组
        //如果变长数组不支持的话，可以改成
        //Sum* p = new Sum[n];
        //delete p[];
        return Sum::GetRet();
    }
};

结语

构造函数、类型转换和 static 成员是 C++ 中构建高效、灵活程序的核心机制。深入理解构造函数的初始化规则、重载与委托，能够优化对象的创建过程；掌握显式与隐式类型转换，可以避免潜在错误并提升代码可读性；而合理使用 static 成员，则能实现数据共享与类级别的控制。这些特性共同增强了 C++ 的抽象能力，为复杂系统的设计提供了坚实基础。通过实践与思考，开发者可以更自如地运用这些工具，写出更简洁、健壮的代码。

愿诸君能一起共渡重重浪，终见缛彩遥分地，繁光远缀天。

在这里插入图片描述

请添加图片描述

【C++】类和对象（下)
HuaiNAN417的博客
08-09 1118
类和对象结尾 下面的程序的运行结果是什么？A.输出 1 1B.输出2 2C.编译报错D.输出1 随机值E.输出1 2F.输出2 1答案是D。【解析】初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的先后顺序无关。按照顺序进行初始化，先对_a2进行初始化，public中用_a1初始化_a2，虽然传参a = 1给了_a1，但此时还未传，所以调用
Constructor argument with object matching
tfx911的专栏
04-12 713
web.xml DrinkService.java package com.vf.constructor.objectmatch; public interface DrinkService { } Alcohol.java package com.vf.constructor.objectmatch; public class
【C++】类和对象（下）：再探构造函数、类型转换、static成员、友元、内部类、匿名对象、拷贝对象时编译器的优化
2402_82757055的博客
09-22 922
的地方。我们有成员变量的声明，对象的定义，那成员变量在哪里定义？就在初始化列表。
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
2301_80955819的博客
09-15 1811
今天我们学习了类和对象相关的新概念和知识，例如：取地址重载、static修饰成员、友元、内部类等，它们对于我们深入学习并理解c++的后续内容，以及实现对象的相关功能有很大帮助。
C++入门全集（4）：类与对象【下】
Eristic0618的博客
03-04 1206
本篇文章围绕C++中类与对象相关知识进行讲解，包含初始化列表、友元、内部类等内容
C++类和对象（下）
2301_81154519的博客
10-21 1073
介绍了初始化列表，类型转换，static成员，友元，内部类，对象拷贝时的编译器优化的知识点
C++类型转换
reyas的博客
07-09 780
我最近开了几个专栏，诚信互三！====> |||：：刷题教程来自网站。|||====> |||：：记录我学习C++的经历，看完你一定会有收获。|||====> |||：：记录我学习Linux的经历，看完你一定会有收获。|||====> |||：：记录我复习C#的经历，，不定期更新。|||====> |||：：记录我学习计算机网络，看完你一定会有收获。|||
C++ 构造函数-2 （初始化列表 - explicit - static 成员 - 只能在栈/堆上创建对象的类）
chihiro1122的博客
05-10 933
也就是说，在C++当中，这个位置不认为是初始化的地方：如上图，这个只是赋值。在这个位置才认为是 初始化。我们之前说过，当我们初始化一个成员的时候，如果是内置类型，不进行处理：但是也不是都不处理，如果这个内置类型，在类当中是定义给了值的：这个不是初始值，这个是 给 初始化列表的缺省值，也就是说，如果我们不对这个内置类型进行处理，那么这个x 就会被 赋 1 （缺省值）这个值，如果我们在初始化列表当中对这个x 进行了赋值，那么这个x 就是 在初始化列表当中初始化的值。
探索 C++ 类 核心概念与不同场景下的使用技巧
专注 C++ 后端开发与 Linux 系统编程，深耕 STL 原理、多线程、内存管理、网络编程与服务端开发。用通俗语言拆解晦涩知识点，持续输出高质量学习笔记、踩坑复盘与面试干货。
10-19 995
本文系统讲解了C++面向对象编程中的几个进阶概念：初始化列表、类型转换、静态成员、友元机制、内部类、匿名对象以及对象拷贝优化。重点解析了初始化列表的三种必用场景、explicit关键字的作用、静态成员的使用规范、友元的封装控制、内部类的特性、匿名对象的生命周期，以及编译器对对象拷贝的优化机制。这些概念虽零散但实用，能显著提升代码效率和可读性，建议合理运用这些特性来优化C++程序设计。
C++深入类与对象
lrhhappy的博客
05-31 814
在上一篇中提到了构造函数，那么这篇再来提一下构造函数，编译器自动生成的默认构造函数对于内置类型不做处理，自定义类型会调用它自己的构造函数。对于自己写的构造函数，之前是在函数体中初始化，当然不止这一种初始化，还有初始化列表的方式进行初始化，那么为什么可以在函数体中初始化还需要初始化列表呢？咱接着往下看！
C++——类和对象(四)
2401_84771520的博客
01-12 1028
之前我们讲解了类和对象的基本知识，也运用到了日期类的实践当中，让我们对这些知识有了更深的了解，没有看过的小伙伴快可以回去再看一眼哦，那本篇文章就继续来讲解类和对象的最后一点知识，那我们就先说到这里，下面开始正文。这里最重要的就是类型转换和编译器的优化，虽然每个编译器的优化是不一样的，但是他确实可以提高效率，剩下的知识就是以了解为主，到这里类和对象就结束啦，不过在STL部分还要持续的运用，所以有不懂的大家还是要在多看两遍哦！大家不要走开，小编持续更新中...
C++ static关键字
qq_30150579的博客
12-05 337
c++ static关键字
类与对象(下)
2501_91052695的博客
12-31 247
在 C++ 面向对象编程中，类与对象是代码组织的核心，但想要真正驾驭它，需要深入理解那些“藏在背后”的进阶特性。从再探构造函数的细节，到对象拷贝时的编译优化，每一个知识点都能让你写出更高效、更优雅的代码。
C++类和对象下篇
陈落的博客
06-02 1180
🐇🔥博客主页：云曦📋系列专栏：💨路漫漫其修远兮 吾将而求索。
从零理解C++四种类型转换：手把手教你static_cast、dynamic_cast的正确用法
w3x4y的博客
02-25 168
本文深入解析C++中四种类型转换操作符的核心用法与安全边界。重点阐述static_cast用于编译期安全的常规转换，而dynamic_cast则为多态类型提供运行时安全检查，是继承体系中安全向下转换的关键工具。通过实战场景对比，帮助开发者规避常见陷阱，编写更健壮的C++代码。
【面试题001】类型转换关键字，空类对象模型，拷贝构造函数，赋值运算符函数...
A201241302241的博客
04-10 136
【面试题001】类型转换关键字，空类对象模型，拷贝构造函数，赋值运算符函数 一，在C++中，有哪4个与类型转换相关的关键字？ 好多书籍，推荐使用类型转换的关键字，但是c风格的类型转换操作，确实很方便，但是不易掌握。 1、const_cast 号称唯一具有常量性移除的转型操作符，这个说法实在很废话，不解释。平时几乎没有用过，遇到需要这个关键字的时候，都是直接修改了接口的类...
C++类与对象下
JJR_YZ的博客
10-14 877
室友还在看凌晨的世界赛，而我已开卷C++类与对象啦
嵌入式C/C++核心特性深度解析：const、volatile、static与RAII工程实践
最新发布
weixin_42506884的博客
03-22 523
在嵌入式开发中，C/C++语言特性不仅是语法元素，更是构建安全、高效、可维护系统的核心契约机制。理解const的不可变语义与volatile的硬件可见性，是实现正确寄存器访问和中断同步的基础；static控制作用域与生命周期，支撑模块化设计与资源隔离；this指针与RAII共同保障面向对象资源管理的确定性；而inline与模板则提供零成本抽象能力。这些特性协同构成嵌入式软件的底层工程范式，广泛应用于驱动开发、RTOS封装、硬件抽象层（HAL）及实时通信协议栈等关键场景。
c++类和对象
gemgod的博客
04-16 546
本文将对c++类和对象的进行简单介绍
C++中static、const使用方法简介
qq_34122708的博客
08-15 1615
    众所周知，在c++中，static和const的使用方法是难点，也是重点，值得我们随时温习，所谓温故而知新是也。     下面我们首先说一说static。     1、static的作用      static变量的作用，主要可以归纳为以下几点       a、可以隐藏，如果在函数体外声明成员变量，非static的成员变量，在A.cpp中声明：int a;那么这样其他源文件比如B....
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

散峰而望

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值