小编abu*_*amq的帖子

我已经扩展了std :: string来满足我不得不将自定义函数构建编写到名为CustomString的字符串类中的需求

我已经定义了构造函数:

    class CustomString : public std::string {
    public:
        explicit CustomString(void);
        explicit CustomString(const std::string& str);
        explicit CustomString(const CustomString& customString);
        //assignment operator
        CustomString& operator=(const CustomString& customString);
    ... };

在第三个构造函数(复制构造函数)和赋值运算符中,其定义为:

CustomString::CustomString(const CustomString& customString):
    std::string(static_cast<std::string>(customString)) 
{}
CustomString& CustomString::operator=(const CustomString& customString){
    this->assign(static_cast<std::string>(customString));
    return *this;
}

首先,因为这是"明确的"; 意味着需要显式转换以分配给另一个CustomString对象; 它抱怨任务.

CustomString s = CustomString("test");

我不确定在哪里确实需要铸造.

如果复制构造函数不是显式的,那么代码可以正常工作,但我想知道并实现显式定义而不是"猜测正确的强制转换".

可能重复:
删除空指针是否安全？

假设我有一个new被调用的类的分配MyClass,分配就像这样简单:

MyClass *myClassPtr = new MyClass();

我存储参考void*我简单说的位置列表

myListOfPointers.add(static_cast<void*>(myClassPtr)); // this has to be void*

后来我释放内存而不是做:

delete myClassPtr

我用:

delete MyListOfPointer.get(0)

(假设myClassPtr引用是零索引.)另外,请注意它必须是void*因为这个列表可以存储不同类型的指针所以我不知道我删除的指针类型:

所以我不能做任何事情:

delete static_cast<MyClass*>(MyListOfPointer.get(0))

这种方式是否会释放正确的内存大小？(sizeof(MyClass))？

注意:
我不是在寻找指向智能指针的任何答案.

我基本上有两个问题可能是相关的,所以我将它们合二为一.

我们应该在传递给函数时通过引用或值传递C++ 11中的枚举类.它继承了原始类型,但它是通过的整个对象吗？因为枚举类是安全的;

enum class MyEnumClass : unsigned short {
    Flag1 = 0,
    Flag2 = 1,
    Flag3 = 2,
    Flag4 = 4,
};

现在让我们说我们有功能sig

const char* findVal(const MyEnumClass& enumClass);
                                     ^
    should this be by const ref?   __|

我的另一个问题是 -

SHOULD IT BE BY MOVE like (MyEnumClass&&) - I am still learning/understanding 
move semantics and rvalue so I am not sure if move semantics are only for 
constructors or can be for member or static funcs -

我一直在尝试使用extern来使用先前定义的变量.

我以前没有使用extern,现在我需要使用它来定义变量一次并在多个文件中使用它们

我已经为这个问题编写了最小化代码版本.我有四个文件

lib.h

#ifndef LIB_H
#define LIB_H

#include <iostream>

namespace lib {

  extern bool initialized;

  bool initialized = false;

  static void isInit(char* parent) {
    std::cout << "Library for [" << parent << "] initialized? " << (::lib::initialized ? "yes" : "no") << "\n";
  }
} // namespace lib
#endif

vehicle.h

#ifndef _VEHICLE_H
#define _VEHICLE_H
#include <string>

class Vehicle {
  public:
    Vehicle(const std::string& manufacturer,
            const std::string& model,
            int year);
    std::string manufacturer;
    std::string model;
    int year; 
};
#endif

以下是vehicle.h文件的实现,名为vehicle.cpp

#include "vehicle.h" …

假设我们有模板类

template <typename T>
class MyTem{
public:
    bool is_T_Pointer(){
        <...>
    }
};
class Cls : MyTem<Cls>{
    <...>
};
int main(void){
    Cls* classOnHeap = new Cls(); /* T is pointer */
    Cls classOnStack; /* T is not pointer */
    <...>
}

我知道这是一个不好的例子，但如果有人能帮我找出 T 是否是来自模板类的指针，那就太好了。

请记住，我们具有与基类相同类的模板的继承。

不必是完整的实现，一个模糊的技术就足够了

考虑一段代码

int main(int argc,char* argv[]){
        int *arrPtr = new int[4];
        for (int i=0;i<4;i++)
                arrPtr[i]=i*2;


        for (int i=0;i<10;i++){
                arrPtr++;
                cout<<"arrPtr ["<<i<<"]\t"<<*arrPtr<<endl;
        }
        cout<<endl;
        return 0; }

当我编译这个程序

g ++ main.cpp -o main && ./main

它给了我

arrPtr [0]  2
arrPtr [1]  4
arrPtr [2]  6
arrPtr [3]  0
arrPtr [4]  135145
arrPtr [5]  0
arrPtr [6]  0
arrPtr [7]  0
arrPtr [8]  0
arrPtr [9]  0

我希望能够在arrPtr未指向"valid"元素时检测(抛出或检查).在上面的代码中,最后一个有效元素是arrPtr [3].

请不要"我太"的答案!