C++ 类设计规则及注意事项

如何设计一个C++的类? 阅读详情

C++ 类设计规则及注意事项

一、概述

C++可用于解决各种类型的编程问题,但不能将类设计简化成带编号的例程。下面将简单介绍类设计中的部分设计规则及注意事项。

二、编译器生成的成员函数

编译器会自动生成一些公有成员函数—特殊成员函数。这表明这些成员函数很重要,下面将一一说明回顾这些成员函数,并做简单记录。

2.1 默认构造函数

默认构造函数要么没有参数,要么所有的参数都有默认值:

<1> 如果没有定义任何构造函数,编译器将定义默认构造函数,让使用者能够创建对象。假设Star是一个类,则下述代码需要使用默认构造函数:

Star rigel;           // 创建一个不需要显式初始化的对象
Star pleiades[6];     // 创建一个对象数组

<2> 自动生成的默认构造函数的另一项功能是:调用基类的默认构造函数以及调用本身是对象的成员所属类的默认构造函数。

<3> 如果派生类构造函数的成员初始化列表中没有显式调用基类构造函数,则编译器将使用基类的默认构造函数来构造派生类对象的基类部分。在这种情况下,如果基类没有构造函数,将导致编译阶段错误。

<4> 如果定义了某种构造函数,编译器将不会定义默认构造函数。在这种情况下,如果需要默认构造函数,则必须自己提供。

为什么要提供构造函数或者提供构造函数的动机?:

<1> 提供构造函数的动机之一是确保对象总能被正确的初始化。

<2> 如果类包含指针成员,则必须初始化这些成员。因此,最好提供一个显式默认构造函数,将所有的类数据成员都初始化为合理的值。

2.2 复制构造函数

复制构造函数接受其所属类的对象作为参数。例如,Star类的复制构造函数的原型如下:

Star(const Star &s);

在如下几种情况下将调用复制构造函数:

<1> 将新对象初始化为一个同类对象。

<2> 按值将对象传递给函数。

<3> 函数按值返回临时对象。

<4> 编译器生成临时对象。

复制构造函数的使用注意事项:

<1> 如果程序没有使用(显式或隐式)复制构造函数,编译器将提供原型,但不提供函数定义

<2> 如果程序隐式调用复制构造函数,编译器将提供一个执行成员初始化的复制构造函数。也就是说,新对象的每个成员都被初始化为原始对象相应的成员的值。

<3> 如果成员是类对象,则初始化该成员时,将使用成员相应类的复制构造函数。

<4> 在某些情况下,成员初始化是不合适的。例如,使用new初始化的成员指针通常要求执行深复制(深拷贝),或者类可能包含需要修改的静态变量。在这两种情况下,需要提供自定义的复制构造函数。

2.3 赋值运算符

默认的赋值运算符用于处理同类对象之间的赋值。不要将赋值与初始化混淆了, 具体分辨情况如下:

<1> 如果语句创建新的对象,则使用初始化。

<2> 如果语句修改已有对象的值,则是赋值。

Star sirius;
Star alpha = sirius;    // 初始化
Star dogstar;
dogstar = sirius;       // 赋值

赋值运算符使用注意事项:

<1> 默认赋值运算符为成员赋值。

<2> 如果成员是类对象,则默认成员赋值将使用相应类的赋值运算符。

<3> 如果需要显式定义复制构造函数,则基于相同原因,也需要显式定义赋值运算符。

// Star类赋值运算符原型,赋值运算符函数返回一个Star对象引用
Star& Star::operator=(const Star &);

编译器不会生成将一种类型赋给另一种类型的赋值运算符,但是可由其它方式实现:

<1> 如果希望将字符串赋给Star对象,则方法之一是显式定义下面的运算符:

Start& Star::operator=(const char *)
{
    // Do something
    ...
}

<2> 另一种方法是使用转换函数,将字符串转换成Star对象,然后使用将Star对象赋给Star对象的赋值运算符函数。

<3> 上述两种方法的对比优缺点:

  • 第一种方法(显式赋值运算符)运行速度较快,但需要的代码较多
  • 第二种方法(转换函数)可能导致编译器出现混乱

三、其它类方法注意事项

定义类时,还需要注意以下几点事项,后面将逐一说明各注意事项。

3.1 构造函数

构造函数注意事项如下:

<1> 构造函数不同于其他类方法,因为它创建新对象,而其它类方法只是被现有的对象调用。这是构造函数不被继承的原因之一。

<2> 继承意味着派生类对象可以使用基类的方法,然而构造函数在完成其工作之前,对象并不存在。

3.2 析构函数

析构函数注意事项如下:

<1> 一定要定义显式析构函数来释放类构造函数使用new分配的所有内存,并完成类对象所需的任何特殊的清理工作。

<2> 对于基类,即使他不需要析构函数,也应提供一个虚析构函数。

3.3 转换函数

将其它类型转换为类类型说明及注意事项:

<1> 使用一个参数就可以调用的构造函数定义了从参数类型到类类型的转换,如下所示:

// 将char*转换为Star
Star(const char*);
// 将Spectral转换为Star
Star(const Spectral&, int numbers = 1);

<2> 将可转换的类型传递给以类为参数的函数时,将调用转换构造函数,如下所示:

// 声明一个Star对象
Star north;
// 将字符串赋值给north对象时,先调用转换构造函数
// 再调用赋值运算符函数赋值给north对象
// 上述假设没有定义将char*赋值给Star的赋值运算符
north = "polaris";

<3> 在带一个参数的构造函数原型(声明时)使用explicit将禁止进行隐式转换,仍能进行显示转换。 如下所示:

class Star
{
public:
    explicit Star(const char*);
};

// 声明一个Star对象
Star north;
// 不允许隐式转换,这样是错误的
north = "polaris";
// 允许显示转换,这样是正确的
north = Star("polaris");

将类类型转换为其它类型说明及注意事项:

<1> 要将类对象转换为其它类型,应定义转换函数 :

  • 转换函数可以是没有参数的类成员函数
  • 转换函数可以是返回类型被声明为目标类型的类成员函数
  • 即使没有声明返回类型,函数也应返回所需的转换值

示例如下:

// 将Star转换为double
Star::Star double()
{
    // ...
}
// 将Star转换为const char*
Star::Star const char*()
{
    // ...
}

<2> 应理智的使用转换函数, 仅当它们有帮助时才使用,因为对于某些类,包含转换函数将增加代码的二义性。如下所示:

// 假设已经为Star定义了double转换函数
Star ius(6.0);
// 1、编译器可以将ius转换为double类型,再通过double加法与16.6相加
// 2、编译器或者将16.6转换为Star,再通过Star的加法运算符与ius相加
// 3、但是编译器处理能指出二义性以外,其它什么也不做
Star lix = ius + 16.6;

<3> c++支持将关键字explicit用于转换函数。同构造函数一样,explicit允许使用显示转换,但不能进行隐式转换。

3.4 按值传递对象与传递引用

编写使用对象作为参数的函数时,应按引用而不是按值来传递对象。原因有如下几个方面:

<1> 为了提高效率。按值传递对象涉及到生成临时拷贝,即调用复制构造函数,然后调用析构函数。调用这些函数都需要执行时间,特别是复制大型对象比传递引用花费的时间要多的多。如果函数不修改对象(比方说对象的成员变量),应该将参数声明为const引用。

<2> 继承时可接受派生类。在继承使用虚函数时,被定义为接受基类引用参数的函数可以接受派生类。

3.5 返回对象和返回引用

在实际开发过程中,会发现有的函数直接返回对象,有的函数则是直接返回引用。但是,有的函数必须返回对象,当不必非要返回对象时,则应更改为返回引用。具体说明如下:

<1> 编码方面,直接返回对象与返回引用之间唯一的区别在于函数原型与函数头,如下所示:

// 返回Star对象
Star noval(const Star &);
// 返回Star引用
Star& noval2(const Star &);

<2> 返回引用而不是返回对象的原因在于,返回对象涉及生成返回对象的临时副本,这是调用函数的程序可以使用的副本。因此,返回对象的时间成本包括调用复制构造函数生成副本所需的时间和调用析构函数删除副本所需的时间。返回引用则可以节省时间和内存。

<3> 直接返回对象与按值传递对象相似,他们都生成临时副本;返回引用与按引用传递对象相似,调用和被调用的函数对同一个对象进行操作。

<4> 并不是所有的函数都可以返回引用。函数不能返回在函数中创建的临时对象的引用,因为当函数结束时,临时对象会自动释放掉,因此返回这种引用将是非法的。这种情况下,就应该返回对象了。

返回对象与返回引用的通用规则:

<1> 如果函数返回在函数中创建的临时对象,则不要使用引用。如下所示:

// 重载的+运算符函数
// 通过Star构造函数(假设定义了此构造函数)创建一个新对象,然后返回该对象的副本
Star Star::operator+(const Star& b) const
{
    return Star(x + b.x, y + b.y);
}

<2> 如果函数返回的是通过引用或指针传递给它的对象,则应按引用返回对象。如下所示:

// 假设Star类中声明了total_val成员变量
// topval函数按引用返回调用函数的对象或作为参数传递给函数的对象
const Star& Star::topval(const Star& s) const
{
    if (s.total_val > total_val)
        return s;
    else
        return *this;
}
3.6 使用const

使用const的注意事项:

<1> 保证函数参数不被修改,使用const时应特别注意,可以使用它来确保方法不修改参数,如下所示:

// 不能改变s指向的字符串
Star::Star(const char* s)
{
    // ...
}

<2> 使用const确保方法不修改调用它的对象,如下所示:

// 不能改变调用函数的对象
// 这里的const表示const Star* this,而this指向调用的对象
void Star::show() const
{
    // ...
}

<3> 有时候可以将返回引用的函数放在赋值语句的左侧,这实际上意味着可以将赋值语句右侧的值赋给返回的引用的对象。所以需要使用const来确保返回的引用或指针不能被其它值修改。如下所示:

// 1、该方法返回对this或s的引用。
// 2、因为this和s都被声明为const,所以函数不能对它们进行修改,这意味着返回的引用也必
// 须被声明为const
const Star& Star::topval(const Star& s) const
{
    if (s.total_val > total_val)
        // 返回传递的参数对象
        return s;
    else
        // 返回调用函数的对象
        return *this;
}

<3> 如果函数将参数声明为指向const的引用或指针,则不能将该参数传递给另一个函数,除非后者也确保参数不会被修改。

四、公有继承考虑因素

在程序中使用继承时,有很多需要注意的问题,接下来详细说明各种注意事项。

4.1 is-a关系

<1> 在某些情况下,如果派生类不是一种特殊的基类,则不要使用公有派生。

<2> 在某些情况下,最好的方式可能是创建包含纯虚函数的抽象基类,并从它派生出其它类。

<3> is-a关系的方式之一是,无需进行显式类型转换,基类指针就可以指向派生类对象,基类引用可以引用派生类对象。

<4> 第三条说明,在反过来的情况下是不行的,即不能在不进行显式类型转换的情况下,将派生类指针或引用指向基类对象。这种显式类型转换(向下强制转换)有可能是没有意义的,取决于类声明方式。

4.2 什么不能被继承
4.2.1 构造函数是不能继承

<1> 创建派生类对象时,必须调用派生类的构造函数。然而,派生类构造函数通常使用成员初始化列表语法来调用基类构造函数, 以创建派生对象的基类部分。

<2> 如果派生类构造函数没有使用成员初始化列表语法显示调用基类构造函数,将使用基类的默认构造函数。

<3> 继承链中,每个类都可以使用成员初始化列表将信息传递给相邻的基类。

<4> C++11新增了一种能够继承构造函数的机制(后续再说明),但默认仍不继承构造函数。

4.2.2 析构函数不能被继承

<1> 释放对象时,程序将首先调用派生类的析构函数,然后调用基类的析构函数。

<2> 如果基类有默认析构函数,编译器将为派生类生成默认析构函数

<3> 对于基类,其析构函数应该设置为虚函数

4.2.3 赋值运算符不能被继承

<1> 派生类继承的方法的特征标与基类完全相同,但赋值运算符的特征标随类而异,这是因为赋值运算符包含一个类型为所属类的形参。

4.3 赋值运算符

<1> 如果编译器发现程序将一个对象赋给同一个类的另一个对象,他将自动为这个类提供一个默认的赋值运算符函数。这个赋值运算符的默认或隐式版本将采用成员赋值,即将原对象的相应成员赋给目标对象的相应成员。

<2> 如果对象属于派生类,编译器将使用基类赋值运算符来处理派生类对象中基类部分的赋值。如果显式的为基类提供了赋值运算符,将使用该赋值运算符。与此类似的是,如果对象中的成员是另一个类的对象,则对于改成员,将使用其所属类的赋值运算符。

<3> 如果派生类使用new来初始化指针,则必须提供一个显式赋值运算符。必须给类的每个成员提供赋值运算符,而不仅仅是新成员。如下所示:

// DerivedDMA:派生类  BaseDMA:基类
// style:char指针
DerivedDMA& DerivedDMA::operator=(const DerivedDMA& dv)
{
    if (this == &dv) 
        return *this;
    
    // 显式调用基类赋值运算符
    BaseDMA::operator=(dv);
    delete[] style;
    style = new char[std::strlen(dv.style) + 1];
    std::strcpy(style, dv.style);
    return *this;
}

<4> 将派生类对象赋值给基类对象将会怎样呢?这不同于将基类引用初始化为派生类对象

答:将派生类对象赋给基类对象,只涉及基类的成员赋值

// 基类对象
BaseDMA blips;
// 派生类对象,派生类具有自己独有的成员变量
DerivedDMA snips("Rafe Plosh", 12.3, 34.5, 345);
// 1、赋值语句将被转换为左边的对象调用的赋值运算符函数
// 2、blips.operator=(snips);
// 3、由于左边是基类对象,它将调用BaseDMA::operator=(const BaseDMA&)
// 4、is-a关系允许BaseDMA引用指向派生类对象,如snips
// 5、此类调用只会处理基类成员,忽略派生类成员
blips = snips;

<5> 将基类对象赋值给派生类对象又会怎样呢?

答:调用派生对象的赋值运算符时,派生类引用不能自动引用基类对象,代码不能运行

// 基类对象
BaseDMA blips("Griff Hexbait", 123, 321);
// 派生类对象
DerivedDMA snips;
// 1、赋值语句将被转换为左边的对象调用的赋值运算符函数
// 2、snips.operator=(blips);
// 3、由于左边是派生类对象,它将调用DerivedDMA::operator=(const DerivedDMA&)
// 4、问题出在参数类型上,派生类引用不能自动引用基类对象,因此此赋值代码不能运行
snips = blips;

<6> 将基类对象赋值给派生类对象可行性研究

再来回顾第5条提出的问题,“将基类对象赋值给派生类对象会怎样?”。如果派生类定义转换构造函数及定义了将基类对象赋给派生类对象的赋值运算符,则可以这样做。如果这两个条件都不满足,则不能这样做,除非进行显式强制类型转换。

// 方式一:转换构造函数
// 1、派生类可以定义一个转换构造函数,转换构造函数可以接受一个类型为基类的参数和其它参
// 数,条件是其它参数有默认值
// 2、如果派生类有转换构造函数,程序将通过转换构造函数根据基类对象(传递的参数)来创建
// 一个临时的派生类对象,然后将它用作赋值运算符的参数
DerivedDMA(const BaseDMA& ba, double ml = 100.0, double r = 0.1);

// 方式二:定义将基类赋给派生类的赋值运算符
// 1、该赋值运算符的参数类型与赋值语句匹配,因此无需进行类型转换
DerivedDMA& DerivedDMA::operator=(const BaseDMA &);
4.4 私有成员与保护成员

<1> 对派生类而言,保护成员类似于公有成员;但对于外部而言,保护成员与私有成员类似。

<2> 派生类可以直接访问基类的保护成员,但只能通过基类的成员函数来访问私有成员

<3> 将基类成员设置成私有的可以提高安全性,而将基类成员设置成保护的可以简化代码编写工作,提高访问速度。

4.5 虚方法

<1> 设计基类时,必须确定是否将类方法声明为虚的。

<2> 如果希望派生类能够重新定义方法,则应在基类中将方法声明为虚的,这样可以启用晚期联编(动态联编)

<3> 如果不希望重新定义方法,则不必将方法声明为虚的,这样虽然无法禁止他人重新定义方法,但是可以表示不想被重新定义的思想。

<4> 注意,不适当的代码将阻止动态联编。如下所示:

// 此函数按引用传递参数
void show(const BaseDMA& ba)
{
    ba.ViewAcct();
    std::cout << std::endl;
}

// 此函数按值传递参数
void inadequate(BaseDMA ba)
{
    ba.ViewAcct();
    std::cout << std::endl;
}

// 1、假设将派生类参数传递给上述两个函数调用
// 3、
DerivedDMA buzz("Buzz Parsec", 123.1, 342);
// 1、show函数调用使ba参数成为DerivedDMA类对象buzz的引用
// 2、ba.ViewAcct()被解释为DerivedDMA类的ViewAcct()函数,跟设计预想的一致。
show(buzz);
// 1、inadequate()函数是按值传递,传递参数后,ba参数成为BaseDMA(const BaseDMA &)构
// 造函数创建的一个BaseDMA对象
// 2、自动向上强制转换使的构造函数可以引用一个DerivedDMA对象
// 3、在inadequate()函数中,ba.ViewAcct()被解释为BaseDMA类的ViewAcct()函数,跟设
// 计预想的不一致
inadequate(buzz);
4.6 析构函数

基类的析构函数应该是虚的,这样当通过指向对象的基类指针或引用来删除派生类对象时,程序将首先调用派生类的析构函数,然后调用基类的析构函数,而不仅仅只是调用基类的析构函数。

4.7 友元函数

<1> 由于友元函数并非类成员,因此不能被继承。

<2> 如果希望派生类的友元函数能够使用基类的友元函数,可以通过强制类型转换,将派生类指针或引用转换为基类指针或引用,然后使用转换后的指针或引用来调用基类的友元函数。

// 定义<<运算符友元函数
std::ostream& operator<<(std::ostream& os, const DerivedDMA& dv)
{
    // 1、将DerivedDMA派生类的dv引用强制转换为BaseDMA基类引用
    // 2、可以使用运算符dynamic_cast<>来进行强制转换,转换方式为
    // os << dynamic_cast<BaseDMA &>(dv);
    // 3、转换完成后,调用基类<<运算符友元函数
    os << (const BaseDMA &)dv;
    os << "Style: " << dv.style << std::endl;
    return os;
}
4.8 有关使用基类方法的说明

以公有方式派生的类的对象可以通过多种方式来使用基类的方法,如下:

  1. 派生类对象自动使用继承而来的基类的方法,如果派生类没有重新定义该方法。
  2. 派生类的构造函数自动调用基类的构造函数
  3. 派生类的构造函数自动调用基类的默认构造函数,如果没有在成员初始化列表中指定其它构造函数。
  4. 派生类构造函数显式的调用成员初始化列表中指定的基类的构造函数
  5. 派生类方法可以使用作用域解析运算符来调用公有的和受保护的基类的方法
  6. 派生类的友元函数可以通过强制类型转换,将派生类引用或指针转换为基类的引用或指针,然后使用该引用或指针来调用基类的友元函数。
类的基本原则 阅读详情

相关推荐

C++ 类设计和实现的十大最佳实践

较高的LCOM值通常可以意味着类的内聚性较差。这些公式背后的基本思想可以表述如下: 如果一个类的所有方法都使用它的所有实例字段,那么这个类就是完全内聚的,这意味着sum(MF)=M*F,然后LCOM = 0和LCOMHS = 0。Liskov的行为子类型的概念定义了可变对象可替换性的概念,也就是说,如果S是T的子类型,那么程序中T类型的对象可以被替换为S类型的对象,而不改变该程序的任何期望属性(例如,正确性)。代码库中充斥着嘈杂的注释和不正确的注释,促使程序员忽略所有的注释,或者采取积极的措施隐藏它们。

2301_78588786的博客 356

如何设计高效的C++类

一直以来,使用C++面向对象机制,主要是为了其封装和多态特性。往往设计类时,只是为了功能的堆砌,没有考虑的更加深入。之前也阅读过《Effective C++》,只是那时是在学生时代。如今工作了,重新阅读,有不少新的感悟。最关键的是,能从更高的视角去设计程序,之前杂乱无序的点与点,逐渐连接成一条条线。希望后续能够成面、成立体。回到正题:如何设计C++类?

小熊糖否——木子兮的自留地 3771

从代码学习深度强化学习 - 目标导向的强化学习-HER算法 PyTorch版

经典的深度强化学习算法,如 PPO、SAC 等,在各自擅长的任务中都取得了非常好的效果。但它们通常都局限在解决单个任务上,换句话说,训练好的算法,在运行时也只能完成一个特定的任务。想象一个场景:我们想让一个机械臂能把桌子上的任何一个物体重置到任意一个指定位置。对于传统强化学习而言,如果目标物体的初始位置和目标位置每次都变化,那么这就是一个全新的任务。即便任务的“格式”——抓取并移动——是一样的,但策略本身可能需要重新训练。这显然效率极低。为了解决这类问题,

weixin_43887510的博客 1504

c++中类的设计

在C++中,类是一种数据类型。客观事物是复杂的,要描述它必须从多方面进行,也就是用不同的数据类型来描述不同的方面。

heyi3366的博客 2251

IGBT基础知识

IGBT

u010783226的专栏 1万+

智能车实战——极速越野组GPS与惯导融合定位导航全解析

本文深入解析了智能车极速越野组中GPS与惯导模块的融合定位导航技术。通过对比GPS的全局定位与惯导的高频姿态感知,详细阐述了如何利用MM32SPN27主控,将两者数据融合以实现精准、实时的车辆控制。内容涵盖硬件选型、软件数据处理、PID控制及系统调试等实战环节,为智能车开发者提供了一套完整的解决方案。

pz8901234的博客 1204

C++ 类的设计规则

类是C++ 语言的核心概念,要想写出高质量的C++代码,最重要的事情就是把类设计好,下面介绍一些C++类设计的基本规则。   1 命名          类名一般是名词,用大白话说就是类一般都是个“东西”,根据我的命名原则,业务逻辑中涉及到的所有“东西”在程序中都应该有一个对应的类。          类的方法一般是动词,或者动宾式组合,类方法的隐含的主语就是类自己。 举个例子来说,类名

亮眼看视界 7183

模拟滤波器的基础知识和设计

使用Python实现多种模拟滤波器

faltas的博客 3531

C++中“类”的设计

本篇文章主要介绍了C++中类的设计以及应用。

2401_83046173的博客 1201

SpringBoot+VUE3实战:如何用WebSocket搞定网页端语音通话(避坑指南)

本文详细介绍了如何使用SpringBoot和VUE3结合WebSocket技术实现网页端语音通话功能。从环境配置、WebSocket服务端实现到前端音频处理,提供了完整的开发指南和避坑建议,帮助开发者快速构建稳定高效的实时语音通信系统。

weixin_29021195的博客 221

Android Studio运行报错: failed to load include path ……\platforms\android-35\android.jar的最细解决方案

【代码】Android Studio运行报错: failed to load include path ……\platforms\android-35\android.jar的最细解决方案。

2401_86789230的博客 2万+

《C++新经典设计模式》之附录A 类和对象

类前向声明解决类相互依赖的问题。类A1和类A2直接依赖。一般避免这种设计,而是 引入一个新类,让A1和A2类都依赖于这个新类,从而打破这种类A1和A2的依赖关系。类的前向声明并不是类的完整定义有些情况下,必须要类的完整定义而不是类的前向声明a)在类A1的定义中加入A2类型的对象。b)在类A1的定义中需要知道A2类型对象的大小。c)在类A1的定义中需要调用类A2的成员函数时。

yxqq378287007的博客 1545

材料仿真软件:Materials Studio_(14).电学性质计算

设置计算参数,包括 k 点网格、交换相关泛函等。

kkchenjj的博客 1869

C++ 编码规范

C++编码规范 游戏服务端 目录 C++编码规范 一、通用命名 二、格式 三、类. 四、作用域 五、C++特性 六、协议 七、注释 八、其它 一、通用命名 1.1 简写规则:常用单词缩写简写,如dns、id等,否则最好采用单词全称书写 1.2 局部变量:使用“_”连接,所有单词小写,如user_id 1.3 函数名:首字母小写,其余单词首字...

343

基于TIA博途的一阶滞后滤波+中位值滤波+堆栈平均值滤波算法SCL语言程序(封装FB库)

基于TIA博途的一阶滞后滤波+中位值滤波+堆栈平均值滤波算法SCL语言程序(封装FB库)

Robot_PLC_HMI_Automation 2181

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

C++类的静态数据成员

C++类的静态数据成员

qq_35320456的博客 625

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

不能定义声明dllimport_在 C++ 类中使用 dllimport 和 dllexport

在 C++ 类中使用 dllimport 和 dllexportUsing dllimport and dllexport in C++ Classes11/04/2016本文内容Microsoft 专用Microsoft Specific可以用或属性声明 c + + 类 dllimport dllexport 。You can declare C++ classes with the dllim...

weixin_42298270的博客 1721

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

C++11 defaulted和deleted函数从入门到精通

C++11的defaulted和deleted函数为程序员提供了强大而灵活的工具,能够更精细地控制类的特殊成员函数的生成和使用。通过合理使用这两个特性,可以提高代码的可读性、可维护性和安全性,避免不必要的错误和资源浪费。在实际编程中,我们应该根据具体的需求,灵活运用defaulted和deleted函数,让代码更加健壮和高效。

码事漫谈 1240

c++ 成员默认值_C++对C的扩展

一:内联函数inline宏函数(带参数的宏)的缺点:第一个在c中也会出现,宏看起来像一个函数调用,但是会有隐藏一些难以发现的错误。 第二个问题是c++特有的,预处理器不允许访问类的成员,也就是说预处理器宏不能用作类的成员函数内联函数:内联函数为了继承宏函数的效率,没有函数调用时开销,然后又可以像普通函数那样,可以进行参数,返回值类型的安全检查,又可以作为成员函数内联函数:是一个真正的函数。函数的替...

weixin_36212560的博客 504

C++类和对象

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

2401_88519336的博客 959

【C++】类继承(基类、公有继承、静态联编、动态联编、访问控制)

类继承: 通过继承完成的工作:可在已有类的基础上添加功能;可以给类添加数据;可以修改类方法的行为。 其中derived是派生类,base是基类,x和y是基类构造函数使用的变量。 4. 基类指针可以在不进行显式类型转换的情况下指向派生类对象;基类引用可以在不进行显式类型转换的情况下引用派生类对象。通常,C++要求引用和指针类型与赋给的类型匹配,但这一规则对继承来说时例外。这种例外只是单向的,不可以将基类对象和地址赋给派生类引用和指针。将源代码中的函数调用解释为执行特定的函数代码块被称为函数名联编。在编译过程中

小米子的成长日记 559

c++ 类总结 集锦

class Screen{public:void home(){_cursor = 0;}private:int _cursor;}虽然每个类对象都有自己的类数据成员拷贝。但是每个类成员函数的拷贝“只有一份”!例如:Screen myScreen, groupScreen;myScreen.home();groupScreen.home();其中myScreen, groupScreen调用h...

weixin_30287169的博客 55

c++继承(第一部分)

继承(inheritance)机制是⾯向对象程序设计使代码可以复⽤的最重要的⼿段,它允许我们在保持原有类特性的基础上进⾏扩展,增加⽅法(成员函数)和属性(成员变量),这样产⽣新的类,称。然后我们开始调用栈的push函数,栈此时要实例化push函数,此时就会将T实例化成int,此时再在这里调用push_back在父类里面找是找不到的,在自己类找也找不到,就会报错。但是必须是父类的指针是指向子类对象时才是安全的。我们在类里面访问一下,发现编译错误,证明是不可访问的,但是protected里的成员是可以访问的。

2201_75319436的博客 1005

Google关于C++开源项目的规范

一、头文件规范     1. 每一个cpp文件对应都有.h文件。除非cpp文件很简单或者值包含了main函数。     2. 每一个头文件都定义自己的头文件保护,防止重复引用和编译。     3. 一般都用#include而不是前向定义,除非include的代价过大。     4. 函数定义如果超过10行,坚决不能inline。     5. 函数参数排序,从input到output。

李腾龙 910

C++Simplify02-基础语法

参考《C++ Primer第4版》(中文版) 1.C++变量名规则:数字、字母、下划线构成,不能以数字开头,不能使关键字  书写习惯:全部小写,单词之间用下划线隔开:girl_student、worker_salary 2.变量名的初始化: 复制初始化:int a = 2; 直接初始化:int a(2);  //更灵活,更高效     区别:对于一般的内建类型,这两种初始化基本上没有区

Monica的专栏 1373

高质量C++/C编程指南---类的构造函数,析构函数,赋值

第9章 类的构造函数、析构函数与赋值函数9.1 构造函数与析构函数的起源9.2 构造函数的初始化表9.3 构造和析构的次序9.4 示例:类String的构造函数与析构函数9.5 不要轻视拷贝构造函数与赋值函数9.6 示例:类String的拷贝构造函数与赋值函数9.7 偷懒的办法处理拷贝构造函数与赋值函数

lisamme的专栏 379
上一篇: C++ 继承与动态内存分配
下一篇: C++ has-a关系之包含
渐进者
博客等级 码龄12年 6粉丝 28原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值