我一直在寻找在C++中在堆栈或堆上分配对象的经验法则.我在这里找到了许多关于SO的讨论.很多人说,这是关于物体的寿命.如果您需要比函数范围更长的生命周期,请将其放入堆中.这很有道理.
但令我困惑的是,许多人说,如果它们很小,就会将对象分配给堆栈.如果对象很大,请将其放入堆中.但他们都没有说如何识别物体是否很大？
我有以下问题,
vector<string>.它将有大约100件物品.如果我将这个类分配给堆栈,它是否会导致堆栈溢出？我试过这个,但效果很好.不确定我做错了什么.我正在阅读相关问题,这个问题引导我提出这个问题.
请考虑以下代码
int main()
{
string SomeString();
}
总而言之,编译器将其作为函数原型而不是字符串对象.现在考虑以下代码.
int main()
{
string Some()
{
return "";
}
}
编译器说这是无效的,因为我猜不允许嵌套函数定义.如果不允许,为什么允许嵌套函数原型？它没有给予任何优势而不是混淆(或者我在这里错过了一些有效点？).
我想出以下是有效的.
int main()
{
string SomeFun();
SomeFun();
return 0;
}
string SomeFun()
{
std::cout << "WOW this is unexpected" << std::endl;
}
这也令人困惑.我期待函数SomeFun()只在main中有一个范围.但是我错了.为什么编译器允许编译如上所述的代码？有没有像上面这样的代码有意义的实时情况？
有什么想法吗？
我正在阅读Stroustrup的C++ 0x FAQ,并坚持使用这段代码.请考虑以下代码
struct A
{
void f(double)
{
std::cout << "in double" << std::endl;
}
};
struct B : A
{
void f(int)
{
std::cout << "in int" << std::endl;
}
};
int main()
{
A a; a.f(10.10); // as expected, A.f will get called
B b; b.f(10.10); // This calls b.f and we lose the .10 here
return 0;
}
我的理解是,当一个类型被继承时,所有受保护的和公共成员都可以从派生类访问.但根据这个例子,看起来我错了.我期待bf会调用基类f.我通过改变派生类得到了预期的结果
struct B : A
{
using A::f;
void f(int)
{
std::cout << "in …我的产品有大约10个以上的组件.我们曾经在没有强烈命名组件的情况下发货.但在阅读了强有力的命名之后,我认为强名称组合是一个明智的想法.只是想知道一个最佳实践强名称程序使用的所有程序集？
有什么想法吗？
根据MSDN,SqlDataReader.GetSchemaTable返回执行查询的列元数据.我想知道是否有一个类似的方法将给出给定查询的表元数据？我的意思是涉及哪些表以及它所拥有的别名.
在我的应用程序中,我得到了查询,我需要以where编程方式附加该子句.使用GetSchemaTable(),我可以获取列元数据及其所属的表.但即使表有别名,它仍然返回真正的表名.有没有办法获取该表的别名？
以下代码显示了获取列元数据.
const string connectionString = "your_connection_string";
string sql = "select c.id as s,c.firstname from contact as c";
using(SqlConnection connection = new SqlConnection(connectionString))
using(SqlCommand command = new SqlCommand(sql, connection))
{
connection.Open();
SqlDataReader reader = command.ExecuteReader(CommandBehavior.KeyInfo);
DataTable schema = reader.GetSchemaTable();
foreach (DataRow row in schema.Rows)
{
foreach (DataColumn column in schema.Columns)
{
Console.WriteLine(column.ColumnName + " = " + row[column]);
}
Console.WriteLine("----------------------------------------");
}
Console.Read();
}
这将正确地提供列的详细信息.但是当我看到BaseTableName列时Id,它给出的contact不是别名c …
我有一个模型,有一个叫做的字段category_paths.这是JSONBpostgres.
当我设置category_pathsfrom factory_girl时,factory_girl正在将值类型更改为String.考虑以下代码,即使我分配了一个代码,它也会Hash被更改为String.
FactoryGirl.define do
factory :product do
title "MyString"
after(:build) do |p|
p.category_paths = Hash.new
puts p.category_paths.class # This prints as String
end
end
end
这很奇怪,我无法弄清楚发生了什么.从Rails控制台尝试时,这很好用.只有在工厂使用时才会出现问题.这是factory_girl的工作原理吗？或者有没有办法控制这种行为？
这是产品型号
class Product < ActiveRecord::Base
acts_as_copy_target
searchkick autocomplete: ['brand'], callbacks: :async
scope :search_import, -> { includes(:product_offers) }
has_many :product_offers, autosave: true
validates :title, presence: true
validate :validate_category_paths
end
任何帮助,将不胜感激
我使用以下代码将cpp文件编译为目标文件.
g++ -c main.cpp
上面的代码在main.cpp所在的同一目录中生成.o文件.
任何帮助都会很棒
我是GDB的初学者,我让它正常工作.但是,我想知道如何在大型项目中使用它.我有一个使用makefile和g ++完成构建的项目.为了使GDB正常工作,我们需要使用右侧的调试符号进行编译(g ++ -g文件)？
题
有什么想法吗？
我在头文件中有以下内容.
namespace silc{
class pattern_token_map
{
/* Contents */
};
pattern_token_map* load_from_file(const char*);
}
在CPP文件中(这有适当的包含)
pattern_token_map* load_from_file(const char* filename)
{
// Implementation goes here
}
在另一个CPP文件中.这有所有适当的包括.
void some_method()
{
const char* filename = "sample.xml";
pattern_token_map* map = load_from_file( filename ); // Linker complains about this.
}
我收到一个链接器错误,说明未定义的引用load_from_file.我无法看到这里出了什么问题.
任何帮助,将不胜感激.
编译器:G ++ OS:Ubuntu 9.10
编辑
这是使用的链接器命令.
g++ -L/home/nkn/silc-project/third_party/UnitTest++ -o tests.out src/phonetic_kit/pattern_token_map.o tests/pattern_token_map_tests.o tests/main.o -lUnitTest++
错误来自pattern_token_map_tests.o,功能可用pattern_token_map.o.所以我猜连接的顺序并不是问题所在.(我已从命令中删除了一些文件以简化它)
这个问题与我的最后一个问题有关.我正在尝试使用traits<T> 和解决问题 traits<T*>.请考虑以下代码.
template<typename T>
struct traits
{
typedef const T& const_reference;
};
template<typename T>
struct traits<T*>
{
typedef const T const_reference;
};
template<typename T>
class test
{
public:
typedef typename traits<T>::const_reference const_reference;
test() {}
const_reference value() const {
return f;
}
private:
T f;
};
int main()
{
const test<foo*> t;
const foo* f = t.value(); // error here. cannot convert ‘const foo’ to ‘const foo*’ in initialization
return 0;
}
所以它看起来像编译器不考虑指针性状专业化,并采取返回类型value()为const …