如果我理解正确，则string::begin返回指向字符串中第一个元素的指针。如果是这样，我们为什么不直接使用 &str来获取指针。

是否存在使用begin更好的情况，或者我误解了它的功能？

当我们编写时int a;,并不意味着我们正在创建类int的对象.

1. 这是什么意思？
2. C和C++中int数据类型的类型是什么？
3. 哪个头文件显示它是什么？

在C++中朋友函数/类的真正用途是什么？你能给出一个只有friend正确方法的例子吗？

谢谢

我正在寻找确认,澄清这个代码是否定义良好.

通过将迭代器重新分配给容器erase()函数的结果来擦除循环中容器的元素是很常见的.循环通常有点像这样凌乱:

struct peer { int i; peer(int i): i(i) {} };

int main()
{
    std::list<peer> peers {0, 1, 2, 3, 4, 5, 6};

    for(auto p = peers.begin(); p != peers.end();) // remember not to increment
    {
        if(p->i > 1 && p->i < 4)
            p = peers.erase(p);
        else
            ++p; // remember to increment
    }

    for(auto&& peer: peers)
        std::cout << peer.i << ' ';
    std::cout << '\n';
}

输出: 0 1 4 5 6

在我看来,假设它没有调用未定义的行为,以下可能会更整洁:

struct peer { int …

受理查德鲍威尔的这次cppcon谈话的启发,我创建了以下代码片段来愚弄:

#include <iostream>
using std::cout;
using std::endl;

struct erdos
{
  void who()
  {
    cout << "erdos" << endl;
  }
  float f1;
  float f2;
};

struct fermat : public erdos
{
  float f3;
};

struct fermat2 : public fermat
{
  float f4;
};

struct fermat3 : public fermat2
{
  float f5;
};

int main(void)
{
  erdos e;
  cout << "sizeof(e)" << sizeof(e) << endl;
  fermat f;
  cout << "sizeof(f)" << sizeof(f) << endl;
  fermat2 f2;
  cout << …

我有两个重载函数,一个是"按值调用",另一个是"按引用调用".

int f (int a)
{
    //code
}

int f (int &a)
{
    //code
}

但是,如果我通过const int,它会调用"按值传递"功能,为什么？

const int a=3;
f(a);//calls the call by value function.Why?

我最近遇到了强制转换和多重继承的问题:我需要转换为Base*to Unrelated*,因为特定的Derived类派生了Unrelated类.

这是一个简短的例子:

#include <iostream>

struct Base{
    virtual ~Base() = default; 
};

struct Unrelated{
    float test = 111;    
};

struct Derived : Base,Unrelated{};

int main(){
    Base* b = new Derived;
    Unrelated* u1 = (Unrelated*)b;
    std::cout << u1->test << std::endl; //outputs garbage
    Unrelated* y = dynamic_cast<Unrelated*>(b);
    std::cout << y->test << std::endl; //outputs 111
}

第一个演员显然不起作用,但第二个演员确实有效.我的问题是:为什么第二次演员工作？难道dynamic_cast只适合投射到相关的类类型吗？我认为Unrelated在运行时没有任何关于它的信息,因为它不是多态的.

编辑:我使用colirus gcc作为示例.

我确实理解ODR所说的内容,但我不明白它试图实现的目标.

我看到违反它的两个后果 - 用户将得到语法错误,这是完全正常的.并且可能存在一些致命的错误,并且用户将是唯一一个有罪的人.

作为违反ODR并获得致命错误的例子,我想像这样:

a.cpp

struct A
{
        int a;
        double b;
};
void f(A a)
{
        std::cout << a.a << " " << a.b << std::endl;
}

main.cpp中

struct A
{
        int a;
        int b;

};
void f(A a);

int main()
{

        A a = {5, 6};
        f(a);

        return 0;
}

如果示例与ODR无关,请纠正我.

那么,ODR是否试图禁止用户做这些有害的事情？我不这么认为.

是否试图为编译器编写者设置一些规则,以避免潜在的危害？可能不会,因为大多数编译器都没有检查ODR违规.

还有什么？

我有一个抽象类，例如Animal。Animal 有一个纯虚函数eat，如果每个动物不想挨饿，就必须实现它。我确保只能通过这种方式实例化 Animal 的孩子：

动物.hpp

class Animal
{

public:

    enum eAnimal{
        CAT=0,
        DOG=1,
        BIRD=2
    };

    // Instantiates the desired animal.
    static Animal GetAnimal(const int animal);

    virtual void Eat() const = 0;

protected:

    Animal();
};

动物.cpp

Animal Animal::GetAnimal(const int animal)
{
    switch(animal)
    {
    case CAT:
        return Cat();
    case DOG:
        return Dog();
    case BIRD:
        return Bird();
    default:
        cerr << "Animal not recognized." << endl;
        exit(-1);
    }
}

Animal::Animal()
{}

有了这个，猫将是：

猫.hpp

class Cat : public Animal …

在像std :: atomic :: compare_exchange这样的函数中,有一些运行时参数,比如std :: memory_order_release,std :: memory_order_relaxed.(http://en.cppreference.com/w/cpp/atomic/atomic/compare_exchange)

我不确定这些内存顺序标志是否保证存在于各种cpu /架构中,如果某些cpus不支持标志,这个标志是否会导致崩溃或？似乎这些标志中的一些是为intel itanium等设计的,不确定std :: memory_order相关代码是否可移植.

你能提一些建议吗？