小编Joh*_*ing的帖子

可能重复:
C字符串文字:它们去哪里了？

如果我有以下代码

char *str = "Tryout" ; 

字符串将存储在哪里？堆？如果是堆栈,指针是否指向堆栈位置呢？

有人告诉我,标准模板库是由每个编译器实现的,这是正确的吗？

如果(例如)使用链表而不是红黑树实现集合容器,如何计算复杂性(时间和空间)？

我错过了什么？

我不太明白我的一个朋友说了什么:

在C++中,如果不知道对象的类型,则无法在对象上调用方法.这不是动态的.在Objective C中,您可以通过执行类似[object message]的操作,在Qt中,您可以使用信号和插槽来完成.在C++ 11中,您也可以这样做

我的问题是:这是正确的吗？

如果可以,请用简单的英语解释我,如果我不知道对象的类型,为什么我不能用C++(而不是C++ 11)中的对象调用方法.

我已经将这个简单的strstr重新制作作为练习,但是有一个我不理解的错误

#include <iostream>
#include "windows.h"

using namespace std;

int strstr2(char *arr, char *findme)
{
    const int sizearr = sizeof(arr) / sizeof(char);
    const int sizefindme = sizeof(findme) / sizeof(char);

    int j=0;
    for(int i=0; i<sizearr; i++)
    {
        if(arr[i] == findme[j])
        {
            // Match
            if(j == sizefindme-1)
                return i;
            else
                j++;
        }
        else
        {
            j = 0;
        }
    }
    return -1;
}


int main (int argc, char **argv) 
{
    char arr[] = "I'd like 2% milk";
    char toBeFound[] = "like";

    int …

我有这个代码

int main()
{
    char A = 'E';

    const char * i;

    i = &A;

    A = 'B';

}

实际上编译MSVC,为什么？是不是const char*应该指向一个常量字符变量？为什么我可以在最后一行将A改为'B'？

我错过了什么吗？

我想知道我是否可以在GPU代码中使用SIMD内在函数,如CUDA内核或openCL代码.那可能吗？

我知道以下代码可以从数组构建一个stl向量:

  // the iterator constructor can also be used to construct from arrays:
  int myints[] = {16,2,77,29};
  std::vector<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );

(来源:cppreference)

使用的构造函数应该是

template <class InputIterator>
         vector (InputIterator first, InputIterator last,
                 const allocator_type& alloc = allocator_type());

如果在上面的例子中<class InputIterator>是<int>,为什么InputIterator首先不是一个整数指针？数组名称"myints"衰变为指向第一个元素的指针,因为它等同于&myints [0]

我认为是正确的版本

template <class InputIterator>
         vector (InputIterator *first, InputIterator *last,
                 const allocator_type& alloc = allocator_type());

我有以下代码,我想知道它为什么写出"22"而不是垃圾

class example
{

public:

    example(int ea) : ref(ea)
    {
    }

    int& ref;
};

int main ()
{
    example obj(22);

    cout << obj.ref; // Writes out 22

    return 0;
}

我认为这应该发生:

• obj(22)将22的隐式转换转换为临时整数
• 整数被复制到int ea参数
• ref通过引用ea参数进行初始化
• ea参数被破坏

为什么参考仍然有效？

当我宣布类似的东西时

#define VAR 1

1值存储在哪里？我不认为在堆中,也不是堆栈..它可能在.bss部分吗？

我有些疑惑static_cast,并dynamic_cast在C++中.是否通过保留已设置的成员变量(除了无法从派生到基础传递的变量除外),它们是否完全将指针指向的对象从类A更改为类B？

我注意到,如果我有类似的东西

struct Base
{
    Base() { }
    virtual ~Base() { }
    virtual void Method() { cout << "Base Method"; }
};

class Derived : public Base
{
public:
    virtual void Method() { cout << "Override Method"; }
};

struct Derived2 : public Derived
{
    Derived2() { cout << "Derived2 constructor"; }
    void Method() { cout << "Override2 Method"; }
};

int main()
{       
    Base *myPointer = new Derived();    
    static_cast<Derived2*>(myPointer)->Derived2::Method(); …