cpp基础知识（4）

Sashtok2026-10-18 16:19

1 再探构造函数

  • 构造函数初始化还有⼀种⽅式，就是初始化列表，初始化列表的使⽤⽅式是以⼀个冒号开始，接着是⼀个以逗号分隔的数据成员列表，每个"成员变量"后⾯跟⼀个放在括号中的初始值或表达式。
cpp 复制代码 
class Sashtok
{
public:
    /*
    Sashtok(int x = 0) : _a(x), _b(nullptr)// 初始值
    {}
    Sashtok(int x = 0) : _a(2 + 5), _b((int*)malloc(sizeof(int)))// 表达式
    {}
    Sashtok(int x = 0)// 也可以这样写 
        : _a(x)
        , _b(nullptr)
    {}
    */
private:
    int _a;
    int* _b;
};
  • 每个成员变量在初始化列表中只能出现⼀次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地⽅。
  • 引⽤成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进⾏初始化，否则会编译报错。
cpp 复制代码 
const int a = 0;
// a = 1; //报错 
// 前情提要，const类型的变量只有一次初始化的机会，就是定义的时候，之后不能再被修改

// 前置声明
class Time；
class Date；

int main()
{
	Date d1(1, 1, 1);// 这是对象的定义
	return 0;
}


class Time
{
public:
	Time(int hour)
		: _hour(hour)
	{}
private:
	int _hour;
};

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1, int& x)
		// 初始化列表是成员变量的定义
		:_n(0)// 所以const成员变量必须在初始化列表中进行初始化
		,_m(x)// 引用在定义时必须初始化，所以只能用初始化列表进行初始化
		,_t(1)// 如果没有默认构造，就要自己定义
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	// 这是成员变量的声明
	int _year;
	int _month;
	int _day;

	const int _n;
	int& _m;
	Time _t;
};
  • C++11⽀持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显⽰在初始化列表初始化的成员使⽤的。
cpp 复制代码 
class Sashtok
{
public:
	Sashtok(int a)
	{}
private:
	// cpp11规定可以写缺省值（也可以写表达式），给初始化列表用
	int _a = 1;
	int* _b = (int*)malloc(8);
	// 缺省值同时弥补了编译器生成的默认构造中，内置类型不初始化的缺点
};
  • 尽量使⽤初始化列表初始化，因为那些你不在初始化列表初始化的成员也会⾛初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会⽤这个缺省值初始化。如果你没有给缺省值，对于没有显⽰在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显⽰在初始化列表初始化的⾃定义类型成员会调⽤这个成员类型的默认构造函数，如果没有默认构造会编译错误。
  • 初始化列表中按照成员变量在类中声明顺序进⾏初始化，跟成员在初始化列表出现的的先后顺序⽆关。建议声明顺序和初始化列表顺序保持⼀致。因为成员变量声明的顺序其实是其在内存中存放的顺序，所以初始化列表按照声明的顺序初始化成员变量。

初始化列表总结：

  1. 显示在初始化列表初始化的值就按这个初始化。
  2. 未显示在初始化列表的成员变量：
    • 类中声明位置有缺省值，就按缺省值初始化。
    • 类中声明位置没有缺省值：
      • 内置类型成员变量：内置类型成员变量，可能初始化为随机值，也可能是默认值0等，具体看编译器。
      • 自定义类型成员变量：调用这个成员的默认构造函数。
      • 引用成员变量/const成员变量/没有默认构造函数的成员变量 必须在初始化列表显示初始化 或者未显示初始化但是声明时有缺省值，否则编译报错

2 类型转换

  • C++⽀持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。
cpp 复制代码 
class Sashtok1
{
public:
    Sashtok(int a = 0)
    {}
private:
    int _a;
};

class Sashtok2
{
public:
    Sashtok(int a = 0, int b = 0)
    {}
private:
    int _a;
    int _b;
};

int main()
{
    // 1构造⼀个Sashtok的临时对象，再⽤这个临时对象拷⻉构造sa
    // 编译器遇到连续构造+拷⻉构造->优化为直接构造
    Sashtok1 sa1 = 1;
    
    const Sashtok1& rsa2 = 1
    
    // C++11之后⽀持多参数转化
    Sashtok2 sa2 = { 2,2 };
    return 0;
}
  • 构造函数前⾯加explicit就不再⽀持隐式类型转换。
cpp 复制代码 
class Sashtok
{
public:
    explicit Sashtok(int a = 0)
    {}
private:
    int _a;
};

int main()
{
    Sashtok sa = 1;// 会报错
    return 0;
}
  • 类类型的对象之间也可以隐式转换，需要相应的构造函数⽀持。
cpp 复制代码 
class A
{
public:
    A(int a1)
        :_a1(a1)
    {}
    int Get() const
    {
        return _a1;
    }
private:
    int _a1 = 1;
};

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

int main()
{
    A a = 1;
    B b = a;// a隐式类型转换为b对象
    const B& rb = a;
    return 0;
}

3 static成员

  • ⽤static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进⾏初始化。
cpp 复制代码 
class A
{
private:
    static int _a;
};
int A::_a = 1;
  • 静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。
  • ⽤static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。
  • 静态成员函数中可以访问其他的静态成员，但是不能访问⾮静态的，因为没有this指针。
  • ⾮静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
  • 突破类域就可以访问静态成员，可以通过类名::静态成员 或者对象.静态成员来访问静态成员变量和静态成员函数。
cpp 复制代码 
class A
{
public:
    static func()
    {
        ++_a;
    }
    
    static int _a;
};
int A::_a = 1;

int main()
{
    // 通过类名
    int i = A::_a;
    A::func();
    
    // 通过对象
    A a;
    i = a._a;
    a.func();
    
    return 0;
}
  • 静态成员也是类的成员，受public、protected、private访问限定符的限制。
  • 静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不⾛构造函数初始化列表。

4 友元

  • 友元提供了⼀种突破类访问限定符封装的⽅式，友元分为友元函数和友元类，在函数声明或者类声明的前⾯加friend，并且把友元声明放到⼀个类的⾥⾯。
  • 友元函数仅仅是⼀种声明，他不是类的成员函数。
cpp 复制代码 
// 友元函数
class A
{
    // 友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制。
    friend void func();
public:
    //friend void func();
protected：
    //friend void func();
    int _a = 0;
private:
    //friend void func();
    int _b = 0;
};

void func()
{
    // 外部友元函数可访问类的私有和保护成员
    return _a + _b;
}
  • ⼀个函数可以是多个类的友元函数。
cpp 复制代码 
// 前置声明
class B;

class A
{
    friend void func(const A& a, const B& b);
private:
    int _a = 0;
};

class B
{
    friend void func(const A& a, const B& b);
private:
    int _b = 0;
};

void func(const A& a, const B& b)
{
    std::cout << a._a + b._b;
}
  • 友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。
cpp 复制代码 
class A
{
    friend class B;
private:
    int _a = 0;
}

class B
{
public:
    void func()
    {
        std::cout << _a;
    }
}
  • 友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元。
  • 友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是C的友元。
  • 友元提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多⽤。

5 内部类

  • 如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。内部类是⼀个独⽴的类，跟定义在全局相⽐，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。
cpp 复制代码 
class A
{
public:
    // 内部类默认是外部类的友元类。
    class B
    {
    public:
        void func()
        {
            cout << _a;
        }
    };
private:
    int _a = 0;
};

int main()
{
    // 定义一个B对象
    A::B b;
    
    return 0;
}
  • 内部类本质也是⼀种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使⽤，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其他地⽅都⽤不了。

6 匿名对象

  • ⽤ <类型>(实参) 定义出来的对象叫做匿名对象，相⽐之前我们定义的 <类型> 对象名(实参) 定义出来的叫有名对象
cpp 复制代码 
class Sashtok
{
public:
    Sashtok(int a = 0)
    {}
private:
    int _a = 0;
};

int main()
{
    Sashtok()// 可以这样定义匿名对象
    Sashtok(1)// 匿名对象
    //Sashtok sa()// 不能这么定义有名对象 
    Sashtok sa(2)// 有名对象
    
    return 0;
}
  • 匿名对象⽣命周期只在当前⼀⾏，⼀般临时定义⼀个对象当前⽤⼀下即可，就可以定义匿名对象。
cpp 复制代码 
class Sashtok
{
};

bool cmp(int a, int b)
{
    return a > b; // 降序
}

int main()
{
    // 代码块的局部域
    {
        Sashtok s;
    }
    // 出了局部域，对象就被销毁了
    
    // 匿名对象的生命周期只在它所在的那一行
    // const& 可以延长匿名对象的生命周期
    
    // 匿名对象的用处，以排序举例
    // 1.
    int a[] = { 5,8,9,1,4,7,3 };
    // sort() 需要包含<algorithm>头文件，同时它在std命名空间下
    std::sort(a, a + 7);// 默认是升序
    // 2.
    int b[] = { 5,8,9,1,4,7,3 };
    std::sort(b, b + 7, cmp);// 传函数指针可以改为降序
    // 3.
    int c[] = { 5,8,9,1,4,7,3 };
    std::greater<int> gr;
    std::sort(c, c + 7, gr);// 这样也可以排成降序，但这里传的是有名对象
    // 4.
    int d[] = { 5,8,9,1,4,7,3 };
    std::sort(d, d + 7, std::greater<int>());// 这样就是传匿名对象传参，更方便点

    return 0;
}

7 对象拷⻉时的编译器优化

  • 现代编译器会为了尽可能提⾼程序的效率，在不影响正确性的情况下会尽可能减少⼀些传参和传返回值的过程中可以省略的拷⻉。
  • 如何优化，C++标准并没有严格规定，各个编译器会根据情况⾃⾏处理。当前主流的相对新⼀点的编译器对于连续⼀个表达式步骤中的连续拷⻉会进⾏合并优化，有些更新更"激进"的编译器还会进⾏跨⾏跨表达式的合并优化。
cpp 复制代码 
class Sashtok
{
public:
    Sashtok(int a = 0)
        :_a(a)
    {
        std::cout << "Sashtok(int a = 0)" << std::endl;
    }
    Sashtok(const Sashtok& s)
        :_a(s._a)
    {
        std::cout << "Sashtok(const Sashtok& s)" << std::endl;
    }
    ~Sashtok()
    {
        std::cout << "~Sashtok()" << std::endl;
    }
    void Print()
    {
        std::cout << _a << std::endl;
    }
    Sashtok& operator++()
    {
        ++_a;
        std::cout << "operator++()" << std::endl;
        return *this;
    }
private:
    int _a;
};

void func1(Sashtok s)
{
}

Sashtok func2()
{
    Sashtok s(2);
    return s;
}

Sashtok func3()
{
    Sashtok s(2);
    ++s;
    return s;
}

int main()
{
    // 首先需明确，优化是与编译器有关的
    // 传参的优化
    Sashtok s1 = 1;// 隐式类型转换，把构造+拷贝构造优化为构造
    func1(Sashtok(1));// 匿名对象的传值传参，把构造+拷贝构造优化为构造
    func1(1);// 相当于隐式类型转换，把构造+拷贝构造优化为构造

    // 传返回值的优化
    func2().Print();// 传值返回，然后调用临时对象的Print()，把把构造+拷贝构造优化为构造  				    // 这里的优化实际上是省去了对象s，直接构造临时对象
                    // 临时对象会在调用完Print()就析构
    std::cout << "********";// 加这行是为了显示出临时对象的析构发生在这一行前
    
    func3().Print();// 更激进的优化，把构造、拷贝构造、前置++优化为一次构造
                    // 直接用++后的值构造匿名对象

    Sashtok s2 = func2();// 把构造+拷贝构造+再次拷贝构造优化为构造+拷贝构造，省去了临时对象
                         // 更激烈的优化会把对象s也省去，直接构造s2

    Sashtok s3;
    s3 = func2();// 这里就有可能不会被优化
                 // 但也可能优化，把s构造后充当临时对象，省去了一次拷贝构造
    return 0;
}

8 总结

这篇笔记深入探讨了类与对象的进阶特性。重点包括：初始化列表对成员变量初始化的真正意义及必须使用的三种场景；static成员属于类而非对象；friend友元打破了封装但需克制使用；以及匿名对象和编译器在拷贝时的优化规则。掌握这些细节，能让我们对C++的内存模型和运行机制有更深刻的认知。

相关推荐
Sashtok1 小时前
cpp基础知识（6）
后端
用户2145549310151 小时前
VeapAI 自然语言操作实战｜第 02 篇：语义层——把系统讲给模型听的四个构件
前端·后端
斑鸠喳喳1 小时前
期货模式 FutureTask
后端
Thneonl1 小时前
一次 rebalance，全组停摆：Kafka lag 从 0 到百万的事故复盘
后端·架构
badhope1 小时前
AI Agent安全治理实战：从API密钥泄露到沙箱隔离的完整防线
后端·llm·agent
武子康1 小时前
旧工具结果写进新回合：两次消费之间的打断窗口
人工智能·后端·agent
许雪里2 小时前
Agent 记忆架构设计：原理 × 业界三大范式 × XXL-AI 落地实践
后端·llm·agent
黄鹂鸟科技4 小时前
进销存系统设计要点：从采购计划、库存监控到成本核算
后端·物联网·系统架构
撸串-研究生4 小时前
基于Spring Boot的智慧社区垃圾分类与回收系统的设计与实现【附源码】
spring boot·后端·分类·垃圾分类·社区管理
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02「全语录+省流版」邵艾伦 × 孙宇晨：聊风口、聊个人IP、聊年轻人如何抓住 AI 时代的机会03GitHub 镜像站点04如何新建文件夹？ 电脑新建文件夹的4种方法05历年考研数学一、数学二、数学三真题试卷及答案PDF06几个好用的ip纯净度检测网站07蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接08Telegram APK 下载安装完整指南 — 2026年最新09苹果iPA游戏软件资源下载网站10Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）