我在程序的某些输入区域遇到了一些麻烦.用户输入特定整数的部分内容.即使他们输入了一个非常精细和花花公子的错误,但我注意到如果他们输入的内容不是像'm'这样的整数类型,那么它将重复循环错误消息.
我有几个函数,其中包含整数输入.这是一个例子.
void Room::move(vector<Room>& v, int exone, int extwo, int exthree, int current)
{
v[current].is_occupied = false;
int room_choice;
cout << "\nEnter room to move to: ";
while(true)
{
cin >> room_choice;
if(room_choice == exone || room_choice == extwo || room_choice == exthree)
{
v[room_choice].is_occupied = true;
break;
}
else cout << "Incorrect entry. Try again: ";
}
}
[解决了]
void Room::move(vector<Room>& v, int exone, int extwo, int exthree, int current)
{
v[current].is_occupied = false;
int room_choice;
cout << "\nEnter …有效C++的第23项规定:首选非成员非友元函数到成员函数.
该项目的整个目的是鼓励封装,以及封装灵活性和功能扩展性,但我的问题是,在采取这些建议时你走了多远？
例如,您可以拥有自己的类,私有数据成员,然后通过将公共函数仅减少为私有数据成员的访问者和/或更改者来采用极简主义方法.然后,每个其他功能都可以是非成员功能.
但是,您是否愿意在可能牺牲代码清晰度的情况下增加封装,并使用访问器和变换器？画线在哪里？
[解决了]
所以我决定尝试创建一个排序的双向链接跳过列表...
我很确定我很清楚它是如何工作的.当您插入x时,程序会在基本列表中搜索放置x的适当位置(因为它已排序),(概念上)翻转一个硬币,如果"硬币"落在a上,那么该元素将被添加到上面的列表中(或者创建一个包含元素的新列表),链接到它下面的元素,再次翻转硬币,等等.如果"硬币"随时落在b上,则插入结束.您还必须在每个列表中存储-infinite作为起点,以便无法插入小于起点的值(意味着永远无法找到它).
要搜索x,您可以从"左上角"(最高列表最低值)开始,然后"向右移动"到下一个元素.如果值小于x,则继续下一个元素等,直到"走得太远"并且值大于x.在这种情况下,您将返回到最后一个元素并向下移动一个级别,继续此链,直到您找到x或x从未找到.
要删除x,您只需搜索x并在每次出现在列表中时将其删除.
现在,我只想制作一个存储数字的跳过列表.我认为STL中没有任何东西可以帮助我,所以我需要创建一个包含整数值的类List,它具有成员函数,搜索,删除和插入.
我遇到的问题是处理链接.我很确定我可以用一个指向前一个元素和前面元素的指针来创建一个处理"水平"链接的类,但是我不知道如何处理"垂直"链接(指向相应的元素)在其他名单？)
如果我的逻辑有任何缺陷请告诉我,但我的主要问题是:
编辑:我已经开始编写一些代码,我正在考虑如何处理List构造函数....我猜测它的构造,"-infinite"值应存储在vectorname [0]元素中,我可以只需在创建后调用insert就可以将x放在适当的位置.
如果我想通过它所拥有的两种变量之一对UDT的向量进行排序,标准库排序是否可以执行此操作,或者我是否需要编写自己的排序函数.
例如,如果你有
struct MyType{
int a;
int b;
};
vector<MyType> moo;
// do stuff that pushes data back into moo
sort(moo.begin(), moo.end()) // but sort it by lowest to highest for a, not b
那么这可能使用stdlib排序吗？谢谢.
我想知道是否有可能,例如,a vector<string>和a vector<double>对应的对,vector<string>按字母顺序排序,同时保持对匹配.
我知道这可以通过创建一个包含两个值并只对其进行排序的类来完成,但我宁愿保留两个单独的向量.
有任何想法吗？
最终守则:
#include "std_lib_facilities.h"
struct Name_pairs
{
vector<string>names;
vector<double>ages;
void quicksort(vector<string>& num, vector<double>& num2, int top, int bottom);
int divide(vector<string>& array, vector<double>& array2, int top, int bottom);
bool test();
string read_names();
double read_ages();
void print();
};
string Name_pairs::read_names()
{
string name;
cout << "Enter name: ";
cin >> name;
names.push_back(name);
return name;
}
double Name_pairs::read_ages()
{
double age;
cout << "Enter corresponding age: ";
cin >> age;
ages.push_back(age);
cout << endl;
return …我想知道你是否可以重载一个操作符并使用它而不改变对象的原始值.
编辑代码示例:
class Rational{
public:
Rational(double n, double d):numerator_(n), denominator_(d){};
Rational(){}; // default constructor
double numerator() const { return numerator_; } // accessor
double denominator() const { return denominator_; } // accessor
private:
double numerator_;
double denominator_;
};
const Rational operator+(const Rational& a, const Rational& b)
{
Rational tmp;
tmp.denominator_ = (a.denominator() * b.denominator());
tmp.numerator_ = (a.numerator() * b.denominator());
tmp.numerator_ += (b.numerator() * a.denominator());
return tmp;
}
我创建了访问器const方法,但是我仍然为每个tmp.denominator_/numerator_收到隐私错误.
如标题中所述,目标是在不使用任何标准库函数或下标的情况下将C样式字符串复制到内存中.
这是我到目前为止[求助]
#include "std_lib_facilities.h"
char* strdup(const char* p)
{
int count = 0;
while (p[count]) ++count;
char* q = new char[count+1];
for (int i = 0; i < count + 1; ++i) *(q + i) = *(p + i);
}
int main()
{
char word[] = "Happy";
char* heap_str = strdup(word);
}
显然问题是分配just *p(相当于p[0])只将字母分配"H"给内存.我不知道如何在没有下标或STL函数的情况下分配C风格的字符串.
我正在编写一个智能指针countptr,我已经达到了减速带.countsptr的基本功能是像任何其他智能指针一样工作,并且还有一个指向单个对象的指针数.到目前为止,代码是:
[解决了]
#include "std_lib_facilities.h"
template <class T>
class counted_ptr{
private:
T* pointer;
int* count;
public:
counted_ptr(T* p = 0, int* c = new int(1)) : pointer(p), count(c) {} // default constructor
explicit counted_ptr(const counted_ptr& p) : pointer(p.pointer), count(p.count) { ++*count; } // copy constructor
~counted_ptr() { --*count; delete pointer; }
counted_ptr& operator=(const counted_ptr& p)
{
pointer = p.pointer;
count = p.count;
++*count;
return *this;
}
T* operator->() const{ return pointer; }
T& operator*() const { return *pointer; }
int Get_count() …我正在阅读有关STL算法的内容,本书指出像find这样的算法使用while循环而不是for循环,因为它是最小的,有效的,并且使用少一个变量.我决定做一些测试,结果并没有真正匹配.
forfind始终比whilefind更好地表现.首先,我简单地通过将10000 ints推回到向量中进行测试,然后使用find从中获取单个值并将其返回到迭代器.我把它计时并输出那个时间.
然后我决定改变它,以便多次使用forfind和whilefind函数(在这种情况下10000次).然而,for循环查找仍然提供了比while find更好的性能.有谁能解释一下？这是代码.
#include "std_lib_facilities.h"
#include<ctime>
template<class ln, class T>
ln whilefind(ln first, ln last, const T& val)
{
while (first!=last && *first!=val) ++first;
return first;
}
template<class ln, class T>
ln forfind(ln first, ln last, const T& val)
{
for (ln p = first; p!=last; ++p)
if(*p == val) return p;
return last;
}
int main()
{
vector<int> numbers;
vector<int>::iterator whiletest;
vector<int>::iterator fortest;
for (int n = 0; n < 10000; ++n)
numbers.push_back(n);
clock_t while1 = clock(); …我正在初始化一个带有= 0xff的无符号短整数(所有位都已设置).然后我将b分配给>> 7,它应该产生(0000 0001)并且确实如此.然而,奇怪的是,当我将c分配给<< 7时,它不等于(1000 0000).我通过输出0x80(1000 0000)和c来测试它,但它们不一样.
这是一些代码:
unsigned short int a = 0xff;
unsigned short int b = a>>7;
unsigned short int c = a<<7; // c should == 0x80
我不确定问题是什么.任何帮助表示赞赏.谢谢.
PS"输出"是指输出0x80和十进制和十六进制形式的c.