小编Alo*_*lok的帖子

当在堆中创建对象时,它(新)做两件事.

1:调用operator new

2:调用构造函数初始化obejct.

我正在尝试创建对象数组,例如4个对象,所以它调用构造函数和析构函数4次才有意义,但它只调用一次运算符new [] ?? 为什么？以下是我试图运行的代码.

#include <iostream>
using namespace std;
class test
{
    public:
       static void *operator new[] (size_t size)
       {
           cout<<"operaotor new called"<<endl;
           return ::operator new[](size);
       }

       test()
       {
          cout<<"constructor called"<<endl;
       }
       ~test()
       {
          cout<<"destructor called"<<endl;
       }
};

int main()
{

     test *k = new test[4];
     delete []k;
}

Deque为访问任何元素(cpp引用)提供了持续的复杂性.在向量中,它总是不变的复杂性(向量中的第一个元素的地址+没有元素)但是它如何用于双端队列？Deque元素不是连续的,那么它如何为访问任何元素提供O(1)时间复杂度？当我运行以下程序时,在向量的情况下它给出了正确的输出但是对于双端队列,它给出了一些任意数字(同意不给出正确的结果,因为元素不是连续的).

vector<int> v1;
deque<int> d1;
for( int i =0; i < 1000000;++i)
    v1.push_back(i);
for( int j =0; j < 1000000;++j)
    d1.push_back(j);
cout << *(&v1[0] +90000) << endl; // output 90000
cout<<  *(&d1[0] +90000)<<endl;   // Output is not the same as expected

我正在尝试使用 chrono.txt 查找 UTC 格式的系统时间。我认为下面的程序只给我当地时间，请有人帮帮我吗？

#include <iostream>
#include <chrono>
#include <ctime>  

auto GetSystemTime() -> uint8_t * {
    auto now = std::chrono::system_clock::now();
    std::time_t currentTime = std::chrono::system_clock::to_time_t(now);
    return reinterpret_cast<uint8_t *>(std::ctime(&currentTime));
}

int main()
{

   std::cout << GetSystemTime();
    
}

如果我使用自定义删除器复制unique_ptr,我会收到编译错误.请有人帮助我.

#include <iostream>
#include<memory>
#include <algorithm>
using namespace std;

auto del = [](int *p) { cout <<"obj deleted "<<endl;delete p;};
int main()
{
   unique_ptr<int, decltype(del)> p1(new int(10), del);
   unique_ptr<int,decltype(del)> p2;
   p2 = std::move(p1);
}

错误:

C:\Program Files (x86)\CodeBlocks\MinGW\lib\gcc\mingw32\5.1.0\include\c++\tuple||In instantiation of 'constexpr std::_Head_base<_Idx, _Head, true>::_Head_base() [with unsigned int _Idx = 1u; _Head = <lambda(int*)>]':|
C:\Program Files (x86)\CodeBlocks\MinGW\lib\gcc\mingw32\5.1.0\include\c++\tuple|353|required from 'constexpr std::_Tuple_impl<_Idx, _Head>::_Tuple_impl() [with unsigned int _Idx = 1u; _Head = <lambda(int*)>]'|
C:\Program Files (x86)\CodeBlocks\MinGW\lib\gcc\mingw32\5.1.0\include\c++\tuple|202|required from 'constexpr std::_Tuple_impl<_Idx, _Head, _Tail ...>::_Tuple_impl() [with unsigned …

我很困惑为什么在抛出excpetion时会调用两次destrctor,以及它们被称为??

#include <iostream> 
using namespace std;
class base
{
 public:
     base(){cout<<"constructor called"<<endl;}
     ~base(){cout<<"destructor called"<<endl;}
};
void fun()
{
     throw base(); //<=- Create temp obj of base, and throw exception

}
int main()
{
    try
    {
        fun();
    }
    catch(...)
    {
        cout<<"handle all exception"<<endl;
    }

}

以下是输出

constructor called
destrctor called
handle all exception
destuctor is called

但是当我添加了复制构造函数时,它从未调用过但是析构函数只调用一次,所以发生了什么？

#include <iostream> 
using namespace std;
class base
{
 public:
     base(){cout<<"constructor called"<<endl;}
     ~base(){cout<<"destructor called"<<endl;}
     base (base &obj){cout<<"copy constructor called"<<endl;}
};
void fun()
{
     throw base(); …

为什么有些这些编译而有些不能编译？

场景1:编译错误 'main' : redefinition; previous definition was 'data variable'

#include <iostream>
using namespace std;
int main;
int main(){ }

场景2:编译错误 syntax error : missing ';' before identifier 'obj

#include <iostream>
using namespace std;
class main { };
int main(){ 
   main obj;
} 

情景3:工作正常

#include <iostream>
using namespace std;
class main { };
int main(){ 
   class main obj;
} 

情景4:工作正常

#include <iostream>
using namespace std;
class main {};
main obj;
int main(){ }

该ff()函数返回一个右值但是当我更改函数的返回值时const,它是否返回左值？为什么下面的输出改变其输出"lvalue reference"到"rvalue reference"当我改变 test ff() { }成const test ff() { }

#include <iostream>
using namespace std;
class test { };
void fun( const test& a)
{
    cout << "lvalue reference"<<endl;
}
void fun(  test&& a)
{
    cout << "rvalue reference"<<endl;
}
const test ff() { } // <<---return value is const now
int main()
{

  fun(ff());
}     

输出:

lvalue reference

#include <iostream>
#include <vector>
using namespace std;
class base
{
    int x;
public:
    base(int k){x =k; }
    void display()
    {
        cout<<x<<endl;
    }

    base(const base&)
    {
        cout<<"base copy constructor:"<<endl;
    }
};
int main()
{
    vector<base> v;
    base obase[5]={4,14,19,24,29};
    for(int i=0; i<5; i++)
    {
        v.push_back(obase[i]);
    }

}

将数据插入向量时,使用复制构造函数将复制到该数据转到向量.

当我运行这个程序时,

1. 对于第一次插入(i = 0),调用一次复制构造函数.
2. 对于第二次插入(i = 1),调用两次复制构造函数
3. 对于第三次插入(i = 3),调用三次复制构造函数
4. 对于第四次插入(i = 3),调用四次复制构造函数
5. 对于第五次插入(i = 4),调用五次复制构造函数

请任何人告诉我为什么会这样？对于每次插入,复制构造函数不应只调用一次吗？

   #include <iostream>
using namespace std;
class Shape
{
  public:
  virtual void draw()=0;
};
class Circle:public Shape
{
  public: 
   void draw(){cout<<"circle "<<endl;}
};
class Rectangle:public Shape
{
  public: 
  void draw(){cout<<"Rectangle "<<endl;}
};

我想创建一个Picture类,我可以在其中绘制不同的形状.我在Picture类构造函数中传递Shape类指针(Abstract),如下所示:

class Picture
{
  public: 
      Shape* s1;
      Picture(Shape *fp): s1(new Shape){}
      void PictureDrawn()
      {
          s1->draw();
      }
};

int main()
{
  Circle cir;  
  Picture pic(cir); 
  pic.PictureDrawn();

}

我收到编译错误.请任何人都可以解释如何正确编写Picture类构造函数,以便我可以制作不同的形状？谢谢

我不确定以下语句有什么问题，它给了我编译错误。我们不能将“auto”与原子变量一起使用吗？

#include <iostream>
#include<future>
#include <atomic>
using namespace std;

int main()
{
  atomic<int> value(10);
  auto   NewValue = value;
}

但如果我用“int”替换“auto”，它就可以工作。为什么？

int main()
{
  atomic<int> value(10);
  int NewValue = value;
}

“auto”编译错误

 ||=== Build: Debug in Hello (compiler: GNU GCC Compiler) ===|
 F:\3d\C++CodeProject\Hello\main.cpp||In function 'int main()':|
 F:\3d\C++CodeProject\Hello\main.cpp|11|error: use of deleted function 
 'std::atomic<int>::atomic(const std::atomic<int>&)'|
C:\Program Files 
(x86)\CodeBlocks\MinGW\lib\gcc\mingw32\5.1.0\include\c++\atomic|612|note: 
declared here|
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 1 second(s)) ===|