我不是初学者,我对以下习语非常熟悉:
typedef struct Foo_ Foo;// I know typedef struct Foo Foo is fine, I'm just trying to make it clearer
struct Foo_
{
int value;
Foo *link;
};
我只是突然感到困惑,因为我的理解是在声明之前不允许使用名称(标识符).但在声明中typedef struct Foo_ Foo,标识符Foo_尚不存在!为什么编译器允许这种情况发生？请问有人对此有所了解,向我解释这种语法的理由是什么？
维基百科引用:目的typedef是为EXISTING类型指定替代名称.
---> 8 ---
感谢所有人提供了这么多有用的信息.
我试着用gcc4.7编译以下代码片段
vector<pair<int,char> > vp = {{1,'a'},{2,'b'}};
//For pair vector, it works like a charm.
vector<tuple<int,double,char> > vt = {{1,0.1,'a'},{2,4.2,'b'}};
但是,对于元组的向量,编译器抱怨:
错误:从初始化列表转换为'std :: tuple'将使用显式构造函数'constexpr std :: tuple <> :: tuple(_UElements && ...)[with _UElements = {int,double,char}; =无效 _Elements = {int,double,char}]'
编译器溢出的错误信息对我来说是完全乱码,我不知道元组的构造函数是如何实现的,但我知道它们完全可以使用统一初始化(如:)tuple<int,float,char>{1,2.2,'X'},因此,我想知道问题是否存在我遇到的只是编译器的TODO或它是由C++ 11标准定义的东西.
任何回复将不胜感激!
我的代码是这样的:
string s = "abc";
char* pc = const_cast<char*>( s.c_str() );
pc[ 1 ] = 'x';
cout << s << endl;
当我使用GCC编译上面的代码片段时,我得到了结果"axc",如预期的那样.我的问题是,char以这种方式修改C++字符串的底层数组是否安全且可移植？或者可能有其他方法直接操作字符串的数据？
仅供参考,我的目的是编写一些可以由C和C++调用的纯C函数,因此,它们只能char*作为参数接受.从char*字符串到字符串,我知道涉及复制,惩罚是不利的.所以,任何人都可以提出一些建议来处理这种情况.
这是我想做的：
const assign = <T extends U, U>(original: T, changes: U) =>
<T>Object.assign({}, original, changes);
interface IFoo {
bar: number,
baz?: string,
quux?: boolean,
}
let foo = <IFoo>{ bar: 42, baz: 'hello' };
assign(foo, { baz: 'world' }); //Compilation Error:
我只是想实现一个类型安全assign。但编译器抛出错误：
“IFoo”类型的参数不能分配给“{ baz: string;”类型的参数。}'。属性 'baz' 在类型 'IFoo' 中是可选的，但在类型 '{ baz: string; }'。
changestype的属性应该始终是 type 的严格子集original，我认为这种分配应该是完全合乎逻辑的。
我如何绕过它，在不牺牲changes参数类型安全的情况下安抚严谨的编译器？
我的代码是这样的:
[Serializable]
[StructLayout(LayoutKind.Sequential,Pack=1)]
struct Foo
{
public byte Bar;
public Foo(byte b){Bar=b;}
}
public static void Main (string[] args)
{
Foo[] arr = new Foo[1000];
for (int i = 0; i < 1000; i++) {
arr[i]=new Foo(42);
}
var fmt = new BinaryFormatter();
using(FileStream f= File.Create("test.bin")){
fmt.Serialize(f,arr);
}
Console.WriteLine (new FileInfo("test.bin").Length);
}
Foo结构会占用这么多字节？每个结构开销的9个字节到底是多少？PS:我正在为中文字符编写一个查找库(它是关于大约70,000个字符的信息),db4o或其他可嵌入数据库(如sqlite)有点膨胀.我认为以纯字符串格式存储所有信息,这是最友好的,但不太灵活.我想将信息保存在列表中并将它们作为二进制序列化存储到存档中,我选择了DotNetZip进行存档.但序列化开销是一个意想不到的障碍.一个更好的序列化解决方案将是好的,否则我将以纯字符串格式保存信息并通过硬编码解析它.
在C#中我可以这样写:
class AnyThing<T>
{
static public T Default = default(T);
}
static void Main ()
{
int i = AnyThing<int>.Default;
Console.WriteLine (i==0);
string s = AnyThing<string>.Default;
Console.WriteLine (s == null);
}
我打算在C++中写一个类似模板类的字典,如果找不到给定的密钥,我希望dict返回通用TVal类型的默认值(零输出).在C#中,默认(T)构造来拯救,而在C++中,我不确定做同样事情的适当方法是什么.
我试着T obj = {}和T* obj = {}用gcc4.7,它工作得很好.我只是不确定它是否是语言规范定义的语法,如果这种类型的代码将是可移植的交叉编译器和平台.我的doudt请帮帮我!提前致谢!
PS:
~~~~~~~~~~
为了确保模板获得ANY类型的默认(零输出)值,即使是那些没有可调用默认ctor的值,我采用了以下机制(受avakar的回答启发):
template<class T>
struct AnyThing
{
static const T& Default ;
private:
static const char temp[sizeof(T)];
};
template<class T> const char AnyThing<T>::temp[] = {};
template<class T> const T& AnyThing<T>::Default = *(T*)temp;
struct st
{
double …我的项目涉及很多反思.所以,我在字典中缓存了代表.问题是我选择使用MethodInfo作为dict键,我试图使用查找方法,这是这样的:
Func<T,R> LookUp(Func<T,R> m)
{
return (Func<T,R>)dict[m.Method];
}
//LookUp(MyCls.Method)
但是,在做了一些测试之后,我发现用一个函数地址来提供LookUp方法,即动态创建过渡代表,有点慢,非常慢:
class MyCls
{
public static void Operate(int whatever){ }
}
class MainClass
{
delegate void Doer<T>(T arg);
static Dictionary<MethodInfo,Delegate> _dict = new Dictionary<MethodInfo,Delegate>();
public static void Main (string[] args)
{
Action<int> dg = MyCls.Operate;
_dict[dg.Method] = Delegate.CreateDelegate(typeof(Action<int>),dg.Method);
//performance test
var start = Environment.TickCount;
for (int i = 0; i < 10000000; i++)
{
//LookUp(dg);//11
//LookUp<int>(MyCls.Operate);//1503
//new MyCls();//431
}
Console.WriteLine (Environment.TickCount-start);
}
static Action<T> LookUp<T>(Action<T> dg)
{
//should return (Action<T>)_dict[dg.Method];
return …码:
class Base<T,U> where T:Base<T,U>,new() where U :class
{
protected static U _val = null;
internal static void ShowValue()
{
if(_val == null)new T(); //Without this line, it won't work as expected
Console.WriteLine (_val);
}
internal static void Virtual()
{
Console.WriteLine ("Base");
}
}
class Deriv :Base<Deriv,string>
{
static Deriv()
{
_val = "some string value";
}
internal static new void Virtual ()
{
Console.WriteLine ("Deriv");
}
}
public static void Main (string[] args)
{
Deriv.ShowValue();
Deriv.Virtual();
}
由于.NET的泛型,我可以创建一堆特定的类,重用通用基类中定义的泛型静态方法.它可以在一定程度上模仿继承多态性.但是为了初始化不同版本的静态字段,我要使用静态构造函数.不幸的是,我们无法直接调用它们,因此,我们必须找到一种方法来触发它的调用.上面给出的例子显示了一种方法.但我不喜欢实例化或反射方法.我们也不能对泛型参数的静态方法进行约束.所以,我想问一下,如果还有其他办法可以做这种工作!
先谢谢! …
如果我写下面的代码,
class MainClass
{
static EventHandler _myEvent= delegate{};
static event EventHandler MyEvent
{
add{_myEvent += value;}
remove{_myEvent -= value;}
}
public static void Main (string[] args)
{
MyEvent(null,EventArgs.Empty);
}
}
编译器会抱怨:错误CS0079:事件MainClass.MyEvent' can only appear on the left hand side of+ ='或` - ='运算符.
为什么存在像这样奇怪的东西呢？如果我不能直接发射事件,为什么我会首先使用这样的东西？这是一个错误(我使用单声道)还是故意精致的设计？谁能请教我这背后的理由？提前致谢.
http://phrogz.net/programmingruby/language.html#table_18.4 上面链接提供的表格只给出了 ruby 运算符的优先级。方法的优先级是什么（或者我应该说：消息/函数）？
例如，当我在 irb 中输入如下内容时
Math.sqrt 2 + 2
结果我得到了 2.0。没有优先级的明确规则，我无法决定在哪里使用括号以及在哪里省略它们。所以，请有人帮助我摆脱这种不确定性。提前致谢！