这是一个实现"三个规则"的例子,我发现:
class Array {
public:
int size;
int* vals;
Array() : size(0), vals(NULL){}
Array( int s, int* v );
Array(const Array&); // 1
Array& operator=(const Array&); // 2
~Array(); // 3
};
Array::~Array() {
delete []vals;
vals = NULL;
}
Array::Array( int s, int* v ){
size = s;
vals = new int[size];
std::copy( v, v + size, vals );
}
Array::Array(const Array& rhs):
size(rhs.size),
vals((rhs.size) ? new int[size] : NULL)
{
if(size)
std::copy(rhs.vals, rhs.vals + rhs.size, vals);
}
Array& …我有一个实现选择排序算法的简单示例：
int main(){
vector<int> vi{ 5, 7, 23, 7, 23, 5,
77, 10, 57, 23, 2 };
int min = 0;
for(int i = 0; i < vi.size() - 1; ++i){
min = i;
for(int j = i + 1; j < vi.size(); ++j){
if(vi[j] < vi[min]){
min = j;
}
}
vi[i] ^= vi[min];
vi[min] ^= vi[i];
vi[i] ^= vi[min];
//int tmp = vi[i];
//vi[i] = vi[min];
//vi[min] = tmp;
}
for(auto i : vi)
cout << i << …I am asked to use SFiNAE to reject non-integral versions of my Pow(T) template function. So if the type deduced is an integral then return argument * argument otherwise do nothing and just inform that the version has been rejected by SFINAE.
Here is my try:
template<typename T>
auto Pow(T x)->std::enable_if_t<std::is_integral<T>::value>
{
return x * x;
}
void Pow(...)
{
std::cout << "rejected by SFiNAE" << std::endl;
}
int main()
{
auto ret = Pow(5); // error here: 'ret': variable …如果我有一个容器，比如std::set指向动态对象的指针，那么我如何释放它的元素？
int main()
{
// new scope
{
int x = 10;
std::set<int*> spi;
spi.insert(new int(1));// elem is a dynamic object init from 1
spi.insert(new int[3]()); // elem is a dynamic array of 3 default-init integers
spi.insert(&x); // elem is address of stack memory object
}
}
那么如何有效地释放具有动态内存的元素呢？
我在理解相互转换方面有一些困难，在 C++ Primer 5 ed. 中对此进行了解释：
“在下面的示例中，我们定义了两种从 B 获取 A 的方法：使用 B 的转换运算符或使用带有 B:// 的 A 构造函数，这通常是在两个类之间进行相互转换的坏主意类型：
struct B;
struct A {
A() = default;
A(const B&); // converts a B to an A
// other members
};
struct B {
operator A() const; // also converts a B to an A
// other members
};
A f(const A&);
B b;
A a = f(b); // error ambiguous: f(B::operator A())
// or f(A::A(const B&))
因为有两种方法可以从 B 获取 A，编译器不知道要运行哪种转换；对 f 的调用不明确。此调用可以使用带 …
我发现我应该std::less用来比较我的对象，以便能够比较 Unrelated 指针（来自不同的序列），因为<如果在那些不相关的指针上使用，只使用关系运算符会产生 UB。
所以为了练习，我已经实现了我的compare功能：
#include <iostream>
using namespace std;
#include <functional>
template <class T>
constexpr int compare(T const& x, T const& y)
{
if(std::less<T>()(x, y))
return -1;
if(std::less<T>()(y, x))
return 1;
return 0;
}
int main()
{
std::cout << compare(std::string("Hello"), std::string("hello")) << std::endl;
std::cout << compare(std::string("hello"), std::string("Hello")) << std::endl;
std::cout << compare(std::string("hello"), std::string("hello")) << std::endl;
std::cout << compare(-7, 1) << std::endl;
int* p1{new int(10)};
int* p2{new int{4}};
std::cout << compare(p2, p1) << std::endl; …如果我有一个函数模板，它的模板参数具有默认参数，并且该函数采用类型参数的非默认参数，那么语言中允许该永远不会使用的默认参数有什么意义？：
template <class T = int>
void foo(T x){cout << x << endl;}
int main()
{
foo("hi"); // T is char const *
foo(); // error
}
如您所见T=int，永远无法使用，因为该函数没有默认参数，因此此上下文中的编译器总是T从传递给foo.
甲char数据类型是不能保证签名，它是该装置上一些实施方式中signed，和对他人它是unsigned。那么为什么人们总是忽略signed限定词呢？
char c = 'C'; // can be signed or unsigned
signed char sc = 'D'; // explicitly signed
unsigned char uc = 'e'; // explicitly unsigned
对于可移植性，我就应该总是限定一个char带有signed如果我想的字符保持负值？
正如我所了解的其他类型，如int, long,short总是signed除非明确限定为unsigned。
我有MSVC++ 15和wxwidgets-3.1.0.我正在阅读使用wxWidgets(2005)的跨平台GUI编程一书.我坚持第5章"绘图和打印"中的代码:
#include <wx/effects.h>
void MyWindow::OnErase(wxEraseEvent& event){
wxClientDC* clientDC = NULL;
if (!event.GetDC())
clientDC = new wxClientDC(this);
wxDC* dc = clientDC ? clientDC : event.GetDC() ;
wxSize sz = GetClientSize();
wxEffects effects;
effects.TileBitmap(wxRect(0, 0, sz.x, sz.y), *dc, m_bitmap);
if (clientDC)
delete clientDC;
}
当我编译上面的代码时,我收到错误:Identifier "wxEffects" is undefined.
我正在尝试构建一个基于 MFC 应用程序对话框的应用程序。运行正常。但我需要插入另一个对话框。那么我怎样才能按下第一个对话框中的按钮来打开新添加的对话框呢？
我正在使用 Microsoft Visual Studio 2015。
插入了，但是怎么创建呢？
谢谢。
我正在学习 Qt，我发现它真的很棒而且更容易一些，因为我已经在 Microsoft 中使用过 MFC。
我开发了一个用于教育用途的科学计算器。但我面临的是：
我想要像现实世界的计算器一样浮动高精度，所以在搜索后我找到了这个函数：
long double ldRes = std::sqrt(3);
QMessageBox m;
m.settext(QString::number(ldRes, 'g', 30));
m.exec();
输出：
1.73205080756887719317660412344
而输出，根据卡西欧计算器，以相同的精度进行相同的操作，应该是：
1.73205080756887729352744634151
所以很明显结果是不一样的，所以有人能告诉我如何使用 Qt 在我的应用程序中获得正确的浮点精度吗？或任何其他图书馆？
我应该使用 GMP MPIR MPFR 吗？
谢谢！
我知道使用（访问值）类型为内置整数类型的未初始化的非静态和非全局对象是未定义的行为。
int x; // x is defined inside a function scope for example main
++x;// UB
signed char c = 127; // max positive value for char on my machine
c++; // UB overflowing a signed char.
到这里还可以，但是无符号类型呢？
unsigned char uc = 255; // ok
uc++; // ok c now has the value 0
在这里没问题，因为溢出无符号将丢弃范围之外的位。
因此，只要分配给无符号的任何值都是无害的：
unsigned int x; // local non-static uninitialized
std::cout << x << '\n';// is it UB or OK?
正如您所看到的，设置为无符号的任何（不确定）值都不会导致 UB，所以这样做是错误的吗？
我不关心什么值，x但我认为它不会造成任何伤害。
如果没问题，那么我想编译器可以使用未初始化的无符号非静态非全局对象生成一个随机值。