《C++编程风格》第二章：一致性

最新推荐文章于 2021-10-26 11:29:00 发布
最新推荐文章于 2021-10-26 11:29:00 发布
阅读量611 收藏
点赞数 1
分类专栏： 《C++编程风格》读后总结 文章标签： 对象 设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luoluozlb/article/details/51900789
版权
原书抄录：
  • 在设计一个类时，程序员通常需要从这两个方面进行考虑。接口必须能够代表一致的抽象，而实现则必须使得对象在行为上与这个抽象保持一致。
  • 任何时候，一个对象都是处于某种状态（state），这种状态是由对象中所有数据成员共同的值决定的。

  • 接口和实现可以通过不同的模型来表示对象状态，这也分别称为逻辑状态和和物理状态。逻辑状态模型通常是物理状态模型的简化，多个物理状态可以对应于一个逻辑状态。

  • 在创建一个类时，一致性是很重要的一个方面。

    • 从外部来看，当客户通过类的公有借口来操作对象时，对象的行为必须是一致的。
    • 从内部来看，类的实现在对象的状态上必须保持是一致的。
规则总结：
  • 构造函数应该使得对象处于定义明确的状态
  • 我们一个考虑使用默认参数的形式来代替函数重载的形式
  • 用一致的方式来定义对象的状态—–这需要识别出类不变性
  • 类的接口定义应该是一致的—–避免产生困惑
  • 对于每个new操作，都要有对应的delete操作
  • 避免对不使用的状态信息进行计算和存储（只有当信息在后续操作中需要用到时，才应该被存储）
  • 在定义operator=时，我们要注意x= x 这种情况
  • ‘用一个通用的函数来代替重复的表达式序列
章后练习题

原题如下：

这里写图片描述

程序清单 2-5 另一个string 类
（注：在代码中，因为类名string与标准库中的string类冲突，我改成了String，#include <iostream.h>改成了#include <iostream>）

#include <iostream>
#include <string.h>
#include <stdlib.h>
using namespace std;

class String {
    struct srep {
        char* s;        // pointer to data
        int   n;        // referenc count
        srep() {    n = 1;  }
    };  
    srep *p;
public:
    String(const char *);       // String x = "abc"
    String();                   // String x;
    String(const String &);     //  String x = String ...
    String& operator=(const char *);
    String& operator=(const String &);
    ~String();
    char& operator[](int i);

    friend ostream& operator<<(ostream&, const String&);
    friend istream& operator>>(istream&, String&);

    friend int operator==(const String &x, const char *s)
        { return strcmp(x.p->s, s) == 0; }

    friend int operator==(const String &x, const String &y)
        { return strcmp(x.p->s, y.p->s) == 0; }

    friend int operator!=(const String &x, const String &y)
        { return strcmp(x.p->s, y.p->s) != 0; }
};

String::String()
{
    p = new srep;
    p->s = 0;
}

String::String(const String& x)
{
    x.p->n++;
    p = x.p;
}

String::String(const char* s)
{
    p = new srep;
    p->s = new char[ strlen(s) + 1 ] ;
    strcpy(p->s, s);
}

String::~String()
{
    if (--p->n == 0){ 
        delete[] p->s;
        delete p;
    }
}

String& String::operator=(const char* s)
{
    if (p->n > 1) {         // disconnect self
        p->n --;
        p = new srep;
    }
    else                    // free old String
        delete[] p->s;

    p->s = new char[ strlen(s) + 1 ];
    strcpy(p->s, s);
    return *this;
}

String& String::operator=(const String& x)
{
    x.p->n ++;  // protect against ''st == st''
    if (--p->n == 0) {
        delete[] p->s;
        delete p;
    }
    p = x.p;
    return *this;
}

ostream& operator<<(ostream& s, const String& x)
{
    return s << x.p->s << "\n";
}

istream& operator>>(istream& s, String& x)
{
    char buf[256];
    s >> buf;   // unsafe, might overflow
    x = buf;
    return s;
}

char & String::operator[](int i)
{
    if (i<0 || strlen(p->s)<i) abort();
    return p->s[i];
}

// sample driver:
// read and echo words from input
// at "done", output words in reverse order



int main()
{
    String x[100];
    int n;

    cout << "here we go\n";
    for (n = 0; cin >> x[n]; n++) {
        if (n==100)
            abort();
        String y;
        cout << (y = x[n]);
        if (y=="done") break;
    }
    cout << "here we go back again\n";
    for (int i=n-1; i>=0; i--) cout << x[i];
    return 0;
}

解答：
2.1：赋值运算符函数返回不确定， 因为出现“x=x”的情况， 导致内存先被释放掉了。之后再拷贝的行为是未定义的。

2.2：
首先我们看3个构造函数, 在构造函数String::String()里面构造了一个空的String， 但在
String::String(const String& x)和String::String(const char* s)
里面却不是空的，但在释放的和拷贝的时候， 默认String对象并不是空的， 因此应该将构造函数String::String()与其他的构造函数保持一致。

最好的方法就是和将两个构造函数合并：

String::String(const char* s = 0)
{
    p = new srep;
    p->s = new char[ strlen(s) + 1 ] ;
    strcpy(p->s, s);
}

另外在赋值函数中String& String::operator=(const char* s) 可能会存在“x=x”的情况， 因此改写为：

String& String::operator=(const char* s)
{
    if(p->s == s){
        return *this;
    }

    if (p->n > 1) {         // disconnect self
        p->n --;
        p = new srep;
    }
    else                    // free old String
        delete[] p->s;

    p->s = new char[ strlen(s) + 1 ];
    strcpy(p->s, s);
    return *this;
}

我们还可以写一个小函数来代替重复的复制操作：

void String::copy(const char *s)
{
    p->s = new char[ strlen(s) + 1 ] ;
    strcpy(p->s, s);
}

修改后的代码：

#include <iostream>
#include <string.h>
#include <stdlib.h>
using namespace std;

class String {
    struct srep {
        char* s;        // pointer to data
        int   n;        // referenc count
        srep() {    n = 1;  }
    };  
    srep *p;

    void copy(const char *);

public:
    String(const char *s = "");     // String x = "abc"
    String(const String &);     //  String x = String ...
    String& operator=(const char *);
    String& operator=(const String &);
    ~String();
    char& operator[](int i);

    friend ostream& operator<<(ostream&, const String&);
    friend istream& operator>>(istream&, String&);

    friend int operator==(const String &x, const char *s)
        { return strcmp(x.p->s, s) == 0; }

    friend int operator==(const String &x, const String &y)
        { return strcmp(x.p->s, y.p->s) == 0; }

    friend int operator!=(const String &x, const String &y)
        { return strcmp(x.p->s, y.p->s) != 0; }
};


void String::copy(const char *s)
{
    p->s = new char[ strlen(s) + 1 ] ;
    strcpy(p->s, s);
}

String::String(const String& x)
{
    x.p->n++;
    p = x.p;
}

String::String(const char* s)
{
    p = new srep;
    copy(s);
}

String::~String()
{
    if (--p->n == 0){ 
        delete[] p->s;
        delete p;
    }
}

String& String::operator=(const char* s)
{
    if(p->s == s){
        return *this;
    }

    if (p->n > 1) {     // disconnect self
        p->n --;
        p = new srep;
    }
    else                    // free old String
        delete[] p->s;

    copy(s);
    return *this;
}

String& String::operator=(const String& x)
{
    x.p->n ++;  // protect against ''st == st''
    if (--p->n == 0) {
        delete[] p->s;
        delete p;
    }
    p = x.p;
    return *this;
}

ostream& operator<<(ostream& s, const String& x)
{
    return s << x.p->s << "\n";
}

istream& operator>>(istream& s, String& x)
{
    char buf[256];
    s >> buf;   // unsafe, might overflow
    x = buf;
    return s;
}

char & String::operator[](int i)
{
    if (i<0 || strlen(p->s)<i) abort();
    return p->s[i];
}

// sample driver:
// read and echo words from input
// at "done", output words in reverse order


int main()
{
    String x[100];
    int n;

    cout << "here we go\n";
    for (n = 0; cin >> x[n]; n++) {
        if (n==100)
            abort();
        String y;
        cout << (y = x[n]);
        if (y=="done") break;
    }
    cout << "here we go back again\n";
    for (int i=n-1; i>=0; i--) cout << x[i];
    return 0;
}

运行截图：
这里写图片描述

luoluolzb
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高质量C++编程指南.doc
01-24
第二章“程序的版式”聚焦于代码的视觉呈现和格式规范。良好的代码版式可以提高代码的可读性，降低理解和修改的难度。空行的使用可以区分代码块，代码行的长度和空格的放置影响代码的整洁度。对齐和注释的规范使得...
软件工程第十二.pptx
最新发布
11-16
程序设计语言的选择至关重要，它需要具备一致的表达能力，以便在整个软件开发过程中保持概念的一致性，也有助于维护人员理解软件。可重用性和可维护性也是关键因素，良好的语言特性应能促进代码的复用，并且代码应能...
java什么叫一致性,Java 中的相等性和一致性
weixin_30311521的博客
03-12 553
当在 Set 中存储对象时同样一个对象是不能够存储两次的，这是 Set 的核心定义。在 Java 中，有两个方法分别用来决定两个引用对象是否相同和它们是否都能存在于 Set 中，这两个方法是 equals() and hashCode() 。接下来我将解释下相等性和一致性之间的区别以及它们各自相对来说的优点。Java 为这两个方法都提供了标准的实现，不过标准 equals() 方法定义成一个做相似...
c++ 并行一致性问题，自己的理解，可能有错
weixin_39057744的博客
05-17 313
现在cpu是多条指令并发执行的，并在不影响程序语义正确的情况下，可能会发生编译时指令得排和运行时指令重排 acquire:在本条原子指令后面的访存指令不可以重排序越过本指令 release:在本条原子指令前面的访存指令不可以重排序越过本指令 consume:在本条原子指令后面的依赖于本指令操作变量的指令重排序越过本指令 形象理解： release:当执行到这一步的时候，前面的访存操作能够保证已经执行完成了，向前挡住 acquire: 本指令行面的访存指令不能跑到本指令前面，向后挡住 con..
并发编程之原子性、可见性、有序性的简单理解
dichengyan0013的博客
05-21 354
并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。 原子性：一个操作或多个操作要么全部执行完成且执行过程不被中断，要么就不执行。 可见性：当多个线程同时访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。 有序性：程序执行的顺序按照代码的先后顺序执行。 对于单线程，在执行代码时jvm会进行指令...
C++:75---C++11标准（一致性初始化、初值列：initializer_list）
董哥的黑板报
03-18 1495
一、列表初始化/一致性初始化 设计的目的： 在C++11之前，如何初始化一个变量或对象的概念比较混淆。初始化的场景可以发生在：小括号、大括号或赋值操作符中 C++11引入了“列表初始化/一致性初始化”，意思为：面对任何初始化动作，你可以使用相同语法，就是使用大括号 例如下面的都是正确的： int units_sold = 0; int units_sold = { 0 }; in...
并发编程的数据一致性问题
倔强100%的博客
05-26 542
并发编程的数据一致性问题CPU的优化之路缓存优化MESI协议与可见性伪共享与缓存填充异步处理与指令重排解决CPU优化所带来的问题JMMvolatile关键词可见性非原子性避免指令重排 CPU的优化之路 我们需要了解数据一次性问题，首先需要知道CPU为了更好的性能做了哪些优化。 缓存优化 要了解数据一致性问题产生的原因，我们首先要了解数据的传输路径，我们首先来看下以下这张图。 因为CPU的计算速率远大于IO等数据传输的速率，为了让CPU能持续稳定的007工作，使宝贵的CPU资源得到有效地利用，因此引入了
深入理解一致性与 C++ 内存模型
字节跳动技术团队官方博客
10-26 5146
本文旨在对计算机科学下的一致性模型以及 C++ 的内存模型做一个系统的、深入浅出的介绍。一共 3 个 章节：第 1 章介绍一致性模型，第 2 章介绍 C++ 内存模型，第 3 章是参考资料...
C++程序设计基础教程 苏大C++程序设计教程（第二版） 第11章 面向对象编程（共21页）.pptx
10-10
可读性强调代码的清晰度，可通过良好的编程习惯和一致的编码风格提升。易编程性与抽象程度有关，越高的抽象使得编程更便捷。安全性要求代码不易出错，易于安全运行。可维护性是指局部修改不会影响整体，模块化编程...
高质量的C++编程指南
04-27
第二章“程序的版式”关注代码的可读性和可维护性。2.1节讨论了空行的使用，正确的空行布局可以提高代码的层次感。2.2节和2.3节分别阐述了代码行的长度限制和行内空格的使用，以保持代码的整洁。2.4节介绍了对齐技巧...
高质量C++ 编程规范
11-26
进入第二章，程序的版式是代码可读性的关键因素。代码的缩进、空格、注释和命名约定等都应遵循一致的风格。良好的版式可以使代码看起来整洁，减少阅读和理解代码的时间。这包括但不限于使用标准的缩进（如4个空格）...
高质量C++/C编程指南
04-20
《高质量C++/C编程指南》是一本由林锐博士编写的...总之，《高质量C++/C编程指南》是一部深入浅出的编程参考书，它将帮助程序员提升代码质量，遵循良好的编程习惯，同时也能作为团队开发的标准，促进代码风格的一致性。
高质量C++／C编程指南
05-29
第二章“程序的版式”则关注代码的视觉呈现。良好的代码格式不仅可以提高代码的可读性，也有助于减少潜在的错误。书中提到，空行的使用可以区分不同的功能区域，代码行应简洁明了，避免过于复杂的表达式。代码行内的...
高质量C++C编程指南.doc
11-24
第二章聚焦于程序的版式，这是编程实践中容易被忽视但至关重要的方面。版式包括空行的使用，适当的空行可以使代码逻辑更加清晰；代码行的长度和格式，应保持一致，以便阅读；代码行内的空格使用，可以增强代码的...
Uber Go 语言编程规范：规范 一致性
hero_java的专栏
03-10 192
本文中概述的一些准则可以被客观地评价;其他的，则是有场景的、上下文环境的或主观的。 最重要的一点，是保持一致性。 一致性的代码更容易维护，更容易优化，需要更少的学习成本，并且随着新约定的出现或bug类的修复，更容易迁移或更新。 相反，在一个代码库中有多种不同或冲突的风格会导致维护成本升高、不确定性和认知偏差，所有这些都会直接导致开发效率降低、代码审查繁杂和Bugs。 当将这些指导方针应用到代码库时，建议在包(或更大的)级别上进行更改:子包级别的应用程序在同一代码中引入多种样式，则违反了上述关注点。
一致性——《C++编程风格》读书笔记（三）
gigglesun的专栏
02-02 1498
       对于一个类，可以通过类的接口和类的实现这两方面来进行观察。类的接口由类的公有成员定义，它决定了这个类所创建的对象能够为程序其它部分中的客户代码提供什么样的服务；类的实现是帮助完成这些服务的功能，它们通常是作为类的私有成员被封装起来，客户代码是无法进行反问的。设计一个类时，应注意两点：接口必须能够代表一致的抽象，而实现则必须使得对象在行为上与这个抽象保持一致。      状态：任何
并发编程的原子性一致性有序性的实例
yz18931904的博客
08-04 619
  public class MyClass { private static volatile int count = 0; private static AtomicInteger atomicCount = new AtomicInteger(0); private static int synchronizedCount = 0; public st...
C++编码风格指南(如何写出易读的代码)
yang1fei2的博客
06-27 372
编程跟说话一样，要想言简意赅逻辑清晰，就要学会掌握一定的规则和方法。只有掌握了对应的规则，才能写出优美的程序。这里通过代码留白、代码注释、标识符命名三个方面介绍，如何写出清晰明了的代码。 代码留白 林锐博士，在林锐·高质量C 编程指南之中特别指出了，通过代码留白写出结构松散的代码可以提高代码的易读性。 代码留白指恰当的运用空行分隔代码块，用空格分隔开变量和操作符，保持阅读的节奏。 下面介绍一下代码留白的策略，方便大家的使用，避免生搬硬套。 1.在每个类声明之后、每个函数定义结束之后都要加空行 2
C/C++编程规范：提升代码质量和风格
第二章聚焦于程序的版式，包括空行的使用、代码行的长度限制、空格的布局、对齐原则、长行的拆分、修饰符的位置以及注释的规范。遵循这些版式规范可以使得代码更加整洁易读。 命名规则在第三章中被详细讨论，提出了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值